Description

Add a fast and an idiomatic Kotlin Solution. Both solutions are roughly based around the Java solution. The fast solution focuses on producing clean bytecode while the idiomatic solution focuses on writing more real-world readable code.

Contributing requirements

• [x] I read the contribution guidelines in CONTRIBUTING.md.
• [x] I placed my solution in the correct solution folder.
• [x] I added a README.md with the right badge(s).
• [x] I added a Dockerfile that builds and runs my solution.
• [x] I selected drag-race as the target branch.
• [x] All code herein is licensed compatible with BSD-3.

Description

Scala solution to the Prime Sieve Drag Race.

• Apparently Scala solution_1 is broken*, so this provides the first working implementation on Scala
  • This solution also ~4X faster than solution_1, although comparing to an incorrect solution is fairly pointless
  • Around 4000 passes on my machine (2018 ultrabook, WSL 2 on Win10)
• Used solution_1 as a base for Docker and build files
• Uses tail recursion for the loops (compiled to while loops by the Scala compiler)
• Uses sentinel in the bit (Boolean array) to avoid some out-of-bounds checks
• EDIT: Also adds trivial fix to solution_1 (see discussion)

Solution_1 output*:

2, 3, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97, 
rom1dep;2059635;5.0;1;algorithm=base,faithful=yes

Contributing requirements

• [X] I read the contribution guidelines in CONTRIBUTING.md.
• [X] I placed my solution in the correct solution folder.
• [X] I added a README.md with the right badge(s).
• [X] I added a Dockerfile that builds and runs my solution.
• [X] I selected drag-race as the target branch.
• [X] All code herein is licensed compatible with BSD-3.

Description

Add a Nim version that corrects many of the problems with "solution_1" and "solution_2" including more efficient use of CPU caches and "Extreme Loop Unrolling", which is a technique similar to the "striping" technique used by the fastest Rust implementation, but refined yet further.

Contributing requirements

• [x] I read the contribution guidelines in CONTRIBUTING.md.
• [x] I placed my solution in the correct solution folder.
• [x] I added a README.md with the right badge(s).
• [x] I added a Dockerfile that builds and runs my solution.
• [x] I selected drag-race as the target branch.
• [x] All code herein is licensed compatible with BSD-3.

No longer uses class methods for basic operations. Leaned the loop logic. Uses factor * factor. Uses SplFixedArray rather than normal array, they use less memory and are faster. Enable PHP JIT.

Description

@DennisdeBest Would you like to comment?

Contributing requirements

• [x] I read the contribution guidelines in CONTRIBUTING.md.
• [x] I placed my solution in the correct solution folder.
• [x] I added a README.md with the right badge(s).
• [x] I added a Dockerfile that builds and runs my solution.
• [x] I selected drag-race as the target branch.
• [x] All code herein is licensed compatible with BSD-3.

The following programming languages and their solutions have been checked and fixed based on Dockerlint: PrimeAda PrimeAmd64 PrimeAssembly PrimeAssemblyScript PrimeAWK

~~Note that somehow, i was unable to build PrimAmd64 for example. The dockerfiles look right in my eyes and even with some testing i can see the files. I assume it's just me and i only added versioning on them.

#9 [5/6] RUN ls -al
#9 sha256:3daebede1a2c80e94db8b4f17304c512b69bc8e5e1e381de464b26d0d6d380d7
#9 0.325 total 104
#9 0.325 drwxr-xr-x    1 root     root          4096 Sep  8 19:17 .
#9 0.325 drwxr-xr-x    1 root     root          4096 Sep  8 19:17 ..
#9 0.325 -rwxr-xr-x    1 root     root           705 Sep  7 20:11 build.sh
#9 0.325 -rwxr-xr-x    1 root     root         13407 Sep  7 20:11 primes_ff_bitbtr.asm
#9 0.325 -rwxr-xr-x    1 root     root         14217 Sep  7 20:11 primes_ff_bitshift.asm
#9 0.325 -rwxr-xr-x    1 root     root         12315 Sep  7 20:11 primes_ff_byte.asm
#9 0.325 -rwxr-xr-x    1 root     root         11023 Sep  7 20:11 primes_uff_bitbtr.asm
#9 0.325 -rwxr-xr-x    1 root     root         10989 Sep  7 20:11 primes_uff_bitshift.asm
#9 0.325 -rwxr-xr-x    1 root     root          9189 Sep  7 20:11 primes_uff_byte.asm
#9 0.325 -rwxr-xr-x    1 root     root           160 Sep  7 20:11 run.sh
#9 DONE 0.3s

#10 [6/6] RUN ./build.sh
#10 sha256:24f3007ef2678ffd943c784cb2ca58d2f1a23b4e988c223c540aa612a9ce1576
#10 0.506 /bin/sh: ./build.sh: not found
#10 ERROR: executor failed running [/bin/sh -c ./build.sh]: exit code: 127
```~~

Feel free to review and give feedback, next i'll do another 5 after primeawk :)

I did test in docker playground and it just works from my fork. So i assume it's just a me thing :P 

Created a Nodejs implementation, primarily copied from the C# version.

JS supports bitwise operations for integers, which vastly improves performance compared to using parseInt(index / 2). (I'm pleasantly surprised that it performs significantly better than the Python implementation.)

NOTE: To run using Node.js: run node PrimeJS.js

Hello,

It would be nice to set up some CI to run these implementations in a controlled environment periodically. We're getting benchmarks from different machines, and it is hard to keep track of all the numbers for all the different implementations. We need one source of truth.

On my own box, C++ measures:

Passes: 8665, Time: 5.000000, Avg: 0.000577, Limit: 1000000, Count1: 78498, Count2: 78498, Valid: 1

davepl;8665;5.000000;1

This builds on @EgorBo's PR in https://github.com/davepl/Primes/pull/4 and gets the C# version to:

Passes: 7883, Time: 5.0001565, Avg: 0.0006342961436001523, Limit: 1000000, Count: 78498, Valid: True

tannergooding;7883;5.0001565;1

The key points are to elide bounds checks and more closely mirror what C++ in terms of types and code used to make it a more fair comparison. C# inherently does things C++ doesn't, like bounds checks. If the version to version comparisons were to be equally safe (with C++ using things like std::array and doing bounds checking before accesses, eliding where it is statically determined to be "safe"), then C++ wouldn't have such a "clear lead" 😄

Description

I was able to improve the times even further on dart solution_1 by initializing the bits list to half the sieve size, and adjusting the indexing accordingly.

Contributing requirements

• [x] I read the contribution guidelines in CONTRIBUTING.md.
• [x] I placed my solution in the correct solution folder.
• [x] I added a README.md with the right badge(s).
• [x] I added a Dockerfile that builds and runs my solution.
• [x] I selected drag-race as the target branch.
• [x] All code herein is licensed compatible with BSD-3.

If so, please chime in and volunteer! I wasn't really anticipating the amount of interest and I've got 30+ pull requests and I'm swamped just doing the benchmarking and making the videos, but if someone would like to take over this project and maintain the source to the Drag Racing series, I'd love that!

My goal is to be able to keep the original branch with only a very few changes. I have a few checking queued up of my own, which I will check in, and then leave the main branch alone. I want as few changes in the main branch as possible to keep the tests similar from one episode to the next, but we can party alongside it for sure!

But if folks want to add side-projects for ports to other languages (I know folks have already submitted D, Rust, Java, and others!) the can go in folders alongside, like PrimeJava.

If you're interested, please let me know! Ideally with a one or two snippet of your experience with GitHub!

Thanks! Dave

Benchmarking uses pdftex for its timing facilities

Description

Contributing requirements

• [x] I read the contribution guidelines in CONTRIBUTING.md.
• [x] I placed my solution in the correct solution folder.
• [x] I added a README.md with the right badge(s).
• [x] I added a Dockerfile that builds and runs my solution.
• [x] I selected drag-race as the target branch.
• [x] All code herein is licensed compatible with BSD-3.

Description

Contributing requirements

• [x] I read the contribution guidelines in CONTRIBUTING.md.
• [x] I placed my solution in the correct solution folder.
• [x] I added a README.md with the right badge(s).
• [x] I added a Dockerfile that builds and runs my solution.
• [x] I selected drag-race as the target branch.
• [x] All code herein is licensed compatible with BSD-3.