I am trying to use the AMS Sketch I found in MassDAL Code Bank:
http://www.cs.rutgers.edu/~muthu/massdal-code-index.html
Due to the lack of documentation, I can't figure out what exactly the requested variables are in the functions. In the first one, what exactly are the buckets and depth? Are they a standard or depends on the project?
Related
Where would I find the exact algorithm for generating a Data Matrix ECC200 bar code image that would eventually be printed? I've seen plenty of general explanations but nothing sufficient enough to write code from. I realize of course that there are libraries for this but I'd like to reinvent this particular wheel.
The datamatrix symbology is defined by the standard ISO/IEC 16022 available at:
https://www.iso.org/standard/44230.html
If you poke around the web a bit, you may find a copy....
I am learning to use Castalia for WSN simulation.
I realized that in the user manual, the YYYYMMDD serial number that has been referred to in the examples of obtaining the CastaliaResults was "100809-004640.txt".
However, in the CastaliaPlot to plot the graph, a new number "101209-235427.txt" is being referred to.
Can anybody help with the source of this new number in Castalia 3.2 manual?
As you realised the output files are named with a YYMMDD-HHmmss.txt convention
The name of the actual file does not matter much. They are used as examples in the manual. Obviously you will not have the same filenames when trying out the commands on your own.
In the specific example you mention, it would be better (more consistent) if the manual used the same filename, but it does not matter much.
I wrote the manual. I do not remember exactly what I did all these years back, but the simple explanation for the new filename is that I was rewriting only that part of the manual (the graphs part), so I used some more recent output files to draw the graphs. Probably you can find instances of this minor inconsistency in other places in the manual as well.
We're doing some work on a CPU in logism in class. We're going over the ALU, and need now need to know different ways multiplication can take place. Our professor gave us two examples, one called the "Five Add Time" and the "31 Add Time" (although I do not believe these are the official names of the algorithm), shown here:
And Here
What are the proper names for both these algorithms, and is there any documentation that would allow me to better understand what's going on here? I'd google it, but I am really not sure on the specific term I should look up.
Thanks
A snippet of my task is to generate, let's say, 256 quasi-random numbers using CUDA. I've read cuRAND docs and from there I've learnt that I need to use a set of direction vectors, which I can get using curandGetDirectionVectors32 function. But the problem is that I still can not understand what is 'set of direction vectors'. Especially how to use it, how to limit its length etc.
Also there's no example in Device API Examples with Sobol's generator. And there's no working example in google. I've found some explanation but scrambled_sobol_v_host is not declared in that scope and unclear for me.
So, my question is could anyone, please, provide me with tiny working example of usage of this generator?
And I have troubles with understanding difference between Sobol's generator and scrambled Sobol's generator.
Thank you in advance.
Direction vectors are the seeding method for that number generator. For implementation you should be able to follow using QuasirandomGenerator (for dummies)
I'm interested in implementing the Fast Multipole Method to efficiently simulate a system of repulsive particles.
I've found a large collection of references discussing FMM, but none seem very approachable for non-mathematicians who want to fully understand the algorithm.
Can you recommend a ground-up reference that clearly explains the mathematics behind the process, and includes pseudocode exemplifying a proper implementation?
I am by no means an expert in FMM, but this java implementation and introduction is the best source I've found so far for explaining it carefully and slowly. The paper is good at defining terms before using them, and the code at least is useful as a reference point. The math still gets hairy very quickly, but it is what it is :)
A pedestrian introduction to fast multipole methods is a close second. It doesn't explain the actual details of a working FMM implementation, but it's a good introduction to the basic ideas.
I like the short course on FMM. In begins with FMM in 1D, than it uses theory of complex variable to do FMM in 2D. And than there is the crazy 3D version which uses theory of spherical harmonics functions, which I guess can be very difficult for non-mathematician. But If you need FMM only in 2D you should be fine.
Unfortunately no pseudo codes are given there.
But do you really need the accuracy of FMM?. You might be fine with Barnes-Hut's algorithm
After running into a similar issue to you, I ended up writing a fully-documented Python fast multipole method implementation, pybbfmm. I've also written a short, mathematics-free tutorial on how the method works. Together, I think they're substantially more accessible than any of the other presentations I could find.
(meta: Although this is effectively a linkpost, the OP is explicitly asking for a link. I've added what I think was missing from the last one - the name fo the library - but I'm not sure how else to offer this answer except as a name and a link. Certainly it doesn't feel any more linkpost-y than the accepted answer. If this one gets deleted as well, I'll give up)