Hi everyone! I’m learning about eigenvalue algorithms such as the power method and Lanczos.
I think I understand how it works, starting from a Hermitian matrix H it outputs a tridiagonal matrix T with dimensions n*n where n is the number of iterations.
The sources I have read always stop at this point - but we still don’t have the eigenvalues! My question is, how does having the matrix in tridiagonal form help in computing the eigenvalues? Is there a simple way to obtain them that I’m not seeing?
I'm trying to code up the Lanczos algorithm for eigenvalue approximation at the moment. I've seen on pages like this that the algorithm can't distinguish the eigenvectors if the dimension of the eigenspace is >1, but I don't understand why this makes it actually fail rather than just finish incompletely.
When I run tests the algorithm breaks because it ends up dividing by 0 when trying to find the orthonormal basis. Can anyone direct me to a proof / show my why it fails?
Hey /r/learnprogramming,
I'm beginning a project (condensed matter theory for the curious) that is going to require some programming however I'm not sure which language would best fit my needs, C or python. And unfortunately I don't have any time to experiment with each one to figure out the more suitable language which is why I've come to this subreddit to ask. The project I'm working on will involve the use of matrices, which may become large, and the manipulation of these matrices, as well as the implementation of lanczos algorithms (an iterative algorithm). I'm looking for code that will be efficient and not clumsy when creating and changing the matrices. I worked with MATLAB last year which handled matrices as its main data type but I wasn't a fan of how the language was constructed and used. Can you advise to the more suitable language?
Thanks
This is a PhD thesis for which the digital download is only available on the UC Berkeley campus. The year was 1993.
Also, I'm interested in: Zhuang Wu. The Triple dqds Algorithm for Complex Eigenvalues. 1996.
Make them regret their decision and get the like button back in time for youtube rewind!
I watched this video about the possibility of a 51% attack:
https://www.youtube.com/watch?v=UxyGt58EPa4
I know it's highly, highly unlikely for a variety of reasons but it's still interesting to try to understand.
What I don't totally understand about it: Suppose a miner with 51% hash power publishes their latest blocks, which they mined in private (their version of the blockchain, which is longer than the chain on which all other miners had been working on until then), effectively replacing the last couple of blocks and potentially undoing transactions that were included in them.
Why would the other miners now keep adding to the longest chain? Wouldn't they realise that something is wrong? Why don't they just stick to the chain that they mined on previously? I mean, if a miner goes ahead and replaces the last 20 blocks, the other miners would know something is wrong, wouldn't they?
Just replacing two blocks isn't of much use it seems, unless a receiving party considers a transaction settled after two confirmations.
Softness is better than artefacts, especially when compression is a worry
I have seen this myth grow into becoming a common misconception frequently spread around tech communities such as this one.
I'm going to start by addressing where this misconception comes from, because it isn't a complete lie, but a half truth. FSR consist on EASU (upscaling) and RCAS (sharpening). EASU is a spatial upscaler based on a 2 taps Lanczos. That much is true, but claiming that it's "just Lanczos" means ignoring the much better quality EASU has due to its edge detecting capabilities Lanczos lacks, as well as the much better optimization. EASU gives much cleaner and better resolved edges than Lanczos, getting rid of the blur and ringing artifacts that are so characteristic of Lanczos.
Secondly, I have seen some people mention that Nvidia's Lanczos implementation is better because it uses a 5 taps Lanczos instead of the 2 taps Lanczos of EASU, but more taps doesn't necessarily means more quality. More taps results in a sharper image, but it also results on more noise around the edges with the ringing artifacts becoming more and more evident, so it comes with a trade-off that gets worse the more taps you add. For example, this is how an 8 taps Lanczos looks like vs a 4 taps Lanczos:
To be fair, Lanczos is sharper than EASU, at least the 4 taps Lanczos I used here, but it also looks noisy and the edges look pretty bad in comparison, that's why I consider the clean look of EASU with well defined edges to be better, but some could prefer Lanczos if the noise doesn't bother you.
I cropped the images not only to highlight the parts in where the differences are more evident, but also to get around the Imgur file size limitations, because the original files would get compressed into JPGs and would be worthless for a comparison, but if anyone wants to see them, I uploaded them to Google Drive in a ZIP:
This is the original 1080p image I upscaled to 2160p in the comparisons
For this test I used FidelityFX-CLI for EASU (FSR) and Hybrid for Lanczos. The screenshot is taken from the [official FSR demo](https://github.com/GPUOpen-
... keep reading on reddit ➡The whole thing started with Alex from DF claiming nvidia CP can get a better than FSR by using GPU upscaling.
>Same Lanczos upscale as FSR (with more taps for higher quality) with controllable sharpen.
https://twitter.com/Dachsjaeger/status/1422982316658413573
So I will start off by saying FSR is based on Lanczos however it is much faster which allows better performance and it also solves a few major issues from Lanczos, most notably the ringing artifacts.
I took some screenshot comparisons of FSR vs FSR + RIS vs Lanczos with FidelityFX Sharpening in Rift Breaker vs FSR with Magpie + FidelityFX Sharpening
All images except Native are 720p to 1440p upscaled. Ray Tracing was turned to Max.
https://imgsli.com/NjQ2MDk
Magpie seems to add way more sharpening than the real FSR was even after adding 60% RIS
But anyways lets get back to MagPie to inject fsr vs injecting Lanczos
A super zoomed in on the characters will show the biggest difference in Magpie Lanczos vs Magpie FSR
You can see insane amounts of artifacts on the Lanczos scaling (Right) with a much better impage on the MagPie FSR (Left)
https://imgur.com/iIuIIvs
Not to mention the performance impact on Lanczos is insane.
Because I did not disable Fidelity FX on the MagPie FSR there are some over sharpening artifacts however its still much better than the Lanczos especially on the edges of objects.
tl;dr,
Alex is wrong by saying using Lanczos + Sharpening will give you the same image as FSR even when using Fidelity FX Sharpening on Lanczos its still no where near as good as FSR.
Edit : User below posted MMPeg Lanczos picture too
https://i.imgur.com/Nxcxn5R.png
For those familiar with the two block allocation algorithms used by ZFS (first fit and best fit), does anyone know the reasons why the algorithm is changed at 96% pool capacity (technically I believe it's 96% metaslab capacity which doesn't always translate to 96% pool capacity)? I've read comments that usually seen to hint at reducing fragmentation when the pool gets really full but I've also read that the best fit algorithm increases fragmentation. Based on my understanding of the two algorithms, it would seem that the first fit algorithm would be best at reducing file and free space fragmentation because it searches for the first available block large enough for the data that is closest to and after the previous block (although I would love someone to confirm this understanding cause I might be incorrect ... I am not 100% that it's after the previous block, it might be after something else, but after the previous block makes the most sense). On the other hand the best fit algorithm searches for the smallest block that still fits the data in, I assume, the current metaslab (I'm not sure if it searches other metaslabs before making a decision on which block to use). That would mean that while it might reduce free space fragmentation by filling in empty spaces in the metaslab it actually increases file fragmentation because it will spread the file across blocks that aren't close together but that fit the empty space best. That brings us back to the original question, why use the best fit algorithm after the pool is 96% full? The only answer I can think of is that it's too utilize the remaining space in the most efficient manner at the expense of file fragmentation (and performance).
Sorry if I'm not wording the question in a good way.
I did a small experiment where I had a 1 MB file, and then a copy of that file with only the last byte different (so first N-1 bytes are the same). I then compared compressing each file separately and then both together with zip (Deflate). The archive with both files is double the size of the one with a single file, but there clearly exists a more optimal compression of this where we would only store the first N-1 bytes once.
My understanding is that the LZ algorithm only finds repetitions within a certain sliding window (often 32 kB), so my question is: is there an algorithm that would do a better job where there are huge repetitions like in this case?
I guess we could just compute deltas/increments between files if we know for sure that they are very similar, but that won't work if they are not guaranteed to be.
Hello, I supervised a student that explored an alternative tree based algorithm for block propagation.
The basic assumption is that all nodes participating in the consensus have a common subset of nodes they all know about(validator set). We then construct a (currently) random tree using the message hash as the seed, and the block producer as the root.
The messages are then routed using this tree in order to reduce redundancy present in naive flooding algorithms.
To address the obvious problems when nodes fail, we make some cross links in the tree, where the left subtree checks the children in the right subtree in order to determine if their parent failed to diliver the message, and take over its role.
We ended up implementing it in one of my projects. I wrote a blog post that explains it in some more detail coupled with some testing results. Check it out if interested : https://medium.com/@nionnetwork/p2p-networking-in-nion-abba34d8b5ec
I am looking for any constuctive critisism and feedback to maybe explore other ideas or improve on the existing.
Thank you in advance.
I've heard that all of the B+2C=1 cubic filters do but I've been unable to find similar info on the windowed sinc filters.
Does anyone have any idea how the block signature is generated?
If I have a new account with 1 pending nano transaction how can I generate a signature to sign and publish the block?
I have the new account's seed, secret key, public key, address and hash of the pending block. Just want to generate the signature according to this format:
{
"action": "process",
"json_block": "true",
"subtype": "receive",
"block":{
"type": "state",
"account": "nano_1ip4so3qx9ennz6q8biihne6igsmijgxfqkr18sw4fedfpnk3xx75s417btz",
"previous": "0000000000000000000000000000000000000000000000000000000000000000",
"representative": "nano_1center16ci77qw5w69ww8sy4i4bfmgfhr81ydzpurm91cauj11jn6y3uc5y",
"balance": "30000000000000000000000000000",
"link": "13FDAA395DCD3BF73AE134E9194CAD5B5DBB7B1E72F22772FA7A69AEDBAFB787",
"link_as_account": "5F8ADDB4806F9EC2D8F43B5778A1E77B9E017DDDEBDDBF78428D2F7E60C12245",
"signature": HOW TO GENERATE???,
"work": "5b509c65e46b00fd"
}
}
I went through the nanocurrency-js module but their implementation went over my head. Any golang modules would be appreciated and an explanation would be appreciated even more.
Yup, I’m a D1 vet sitting at 3.5KD so Bungie places me out front every single day and expecting me to carry the trash out day after day. This is BY FAR the most annoying thing in my marriage and has me reconsidering picking up a different FPS. I DO NOT wish to wash the dishes every single day just to be able to see my wife, there is no reason I should get a ‘We Ran out of lube, get us some more, cuck' most days and then still managed to get mercied because I have 32 children that go 0.1, 0.2, and 0.4 in the same the night. This makes my marriage unplayable and unenjoyable. Sure I could LFG for a new wife, but let’s be honest, some of y’all that LFG wives are just as garbage and lusty for Trey. If you manage to go under a 2.0 average cum ratio while in a stack with my wife, the shoe fits you and I will immediately boot you, no questions asked. Bungie Please, for the love of the community, stop putting players that don’t know the cumshot button from the FOMO button on my team. Thanks!
I graduated from a boot camp a little over a year ago and have been bombing technical interviews pretty much ever since. I keep trying to use leetcode/hackerrank etc to "practice" these problems, but I just feel like I'm banging my head against a wall. I don't feel like I'm learning a process for solving them. I can get a few done easily, and then another problem ranked easy will take me days to figure out.
Does anyone have any advice on how to get better at these? I'm feeling really depressed that even the easiest coding challenges seem to completely stump me.
Thanks in advance! In a very low place right now.
