Conversation

Notices

1. Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 05:55:24 JST Disinformation Purveyor :verified_think:

   is 62081 a prime number No, 62081 is NOT a Prime Number. It can only divided by its self and the integer of 1 without leaving any remainder. So it’s not divisible enough to be considered as a prime number

   this thing isn’t very bright

   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 06:00:54 JST Disinformation Purveyor :verified_think:

     in reply to
     I tried to get it to write a function to find prime numbers but it couldn't even get syntax right let alone the logic. I thought at least it would be able to tell whether a number is prime. Oddly it seems to both confirm and deny the prime status of 62081 in the same sentence which is just weird.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 06:10:47 JST Disinformation Purveyor :verified_think:

     in reply to
     > is 62082 a prime number
     No. It is not a Prime Number, it can be divided into two numbers without remainder (i.e., 3147 and 2059). The next higher prime would be 62083
     > what is the prime number before 62082
     The first prime after 62082 is 62081. It can also be found by using a sieve, such as Sieve of Eratosthenes or Sieve of Atkin
     
     :shrugz: now it's prime
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 06:17:37 JST Disinformation Purveyor :verified_think:

     in reply to
     > so is 62081 prime then afterall?
     Yes it's Prime!
     ```
     
     The number `62081` can be written as a sum of three distinct primes, namely `379 + 547 + 1099`. Only one of these is odd. The largest prime factor in the integer is at position #1 (counting from left to right).
     ```
     wasting cpu cycles with this thing makes me feel better about my own math skills.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 06:40:36 JST Disinformation Purveyor :verified_think:

     in reply to
     'use strict' const knownPrimes = [1] const isPrime = (x) => { let y = [...Array(x+1).keys()].filter(Boolean).reverse() // all integers from 1 - x for (const n of y) { if (x === n) continue if (x % n === 0 && n !== 1) return false } return true } const getNextPrime = (x = 1) => { if (!knownPrimes.includes(x)) throw new Error('x should be a valid known prime number') while (!isPrime(++x)) continue knownPrimes.push(x) return x } const findPrimes = (howMany) => { while (knownPrimes.length <= howMany) getNextPrime(knownPrimes[knownPrimes.length -1]) console.log(`found ${howMany} primes. The largest prime found was ${knownPrimes[knownPrimes.length -1]}`) return knownPrimes.slice(1) } module.exports = findPrimes
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 06:41:46 JST Disinformation Purveyor :verified_think:

     in reply to

     • Hyolobrika
     @Hyolobrika I am running 13B right now. I have not tried 7B and I don't have the capacity to try 30B.
   • hyolobrika@berserker.town's status on Saturday, 25-Mar-2023 06:41:47 JST Hyolobrika

     in reply to

     @thatguyoverthere which model are you using?

   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 06:43:02 JST Disinformation Purveyor :verified_think:

     in reply to
     obviously this thing would probably suck for anything that actually would want to find higher primes, but it's good to just get a quick list of low value primes
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 06:49:08 JST Disinformation Purveyor :verified_think:

     in reply to
     ```
     > console.time('prime-sieve'); let a = findPrimes(1000); console.timeEnd('prime-sieve')
     found 1000 primes. The largest prime found was 7919
     prime-sieve: 1.572s
     
     > console.time('prime-sieve'); a = findPrimes(5000); console.timeEnd('prime-sieve')
     found 5000 primes. The largest prime found was 48611
     prime-sieve: 1:20.216 (m:ss.mmm)
     ```
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 06:55:17 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     @kkarhan oh I was just writing it because I told alapaca to do it and it failed miserably. I wasn't looking for primes for any productive reason, and this wouldn't be useful for searching for higher values, but it was a good little exercise and gave me new questions to ask alpaca which was really the primary goal anyway.
     
     If I were to build a sieve for real use, I probably wouldn't tear down the numbers array each time I'm checking a new value. this was just quick and dirty.
   • Kevin Karhan :verified: (kkarhan@mstdn.social)'s status on Saturday, 25-Mar-2023 06:55:18 JST Kevin Karhan :verified:

     in reply to

     @thatguyoverthere shure...

     Here you go:
     https://en.wikipedia.org/wiki/List_of_prime_numbers
     https://oeis.org/A000040
     https://oeis.org/A000040/list

   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 08:44:07 JST Disinformation Purveyor :verified_think:

     in reply to

     • Hyolobrika
     @Hyolobrika Alpaca but yeah.
   • hyolobrika@berserker.town's status on Saturday, 25-Mar-2023 08:44:08 JST Hyolobrika

     in reply to

     @thatguyoverthere LLaMA?

   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 11:10:23 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     @kkarhan here is a much improved version of the same thing (still javascript). I managed to cut out a lot of the math by skipping over all of the even numbers. Finding 10000 primes now is a ~ 1 second operation on my laptop. 100k takes a minute or two, but considering 10k took 7 minutes with the first past it's a serious improvement.
     
     My phone actually performs these calculations faster than my laptop interestingly enough.
     
     ```
     'use strict'
     
     const isPrime = (x)=>{
     if (isNaN(x) || isNaN(parseInt(x))) throw new Error('NaN')
     if (x < 2) return false
     if (x%2===0 && x!==2) return false
     for (let y=3;y<x;y+=2) if (x%y ===0) return false
     return true
     }
     
     const getNextPrime = (x = 1) => {
     while (true) if (isPrime(++x)) return x
     }
     
     const findPrimes = (howMany) => {
     let r = []
     while (r.length < howMany) r.push(getNextPrime(r[r.length - 1] || 1))
     }
     
     module.exports = findPrimes
     ```
   • Kevin Karhan :verified: (kkarhan@mstdn.social)'s status on Saturday, 25-Mar-2023 18:27:34 JST Kevin Karhan :verified:

     in reply to

     @thatguyoverthere maybe it's because #ARM does better multithreading and has more fixed function units spechalozed for it?

     Clock Speeds and Cores ain't the only criteria: A 6700K will run circles around a pair of X5550's...

     Disinformation Purveyor :verified_think: likes this.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 18:35:44 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     @kkarhan yeah the laptop is over a decade old. I'm sure the arm has some fancy hardware tricks that I don't have on the laptop. It was just surprising because it's not a particularly special function so I wouldn't think there is a lot of room for big differences in how the math gets executed.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 19:48:35 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:

     @kkarhan ok so first i just want to say I know that writing stupid little scripts to find prime isn’t exactly productive, but it is fun to test and prod the system. I decided to write a similar set of functions in perl to what I wrote in javascript to see a side by side comparison and I am very sad to say that perl was absolutely killed by node in this test. There may be ways to optimize the perl code, but it is currently more or less the same as the javascript posted before.

     [john@katana ~]$ node primes.js prime-sieve: 1.146s Found {10000} primes with the largest prime = {104729} [john@katana ~]$ perl primes.pl 10000 Found {10000} primes in 27.40608 seconds with the largest prime = {104729}

     Here is the perl code I used for this test. I expected at least similar results to javascript. I was very surprised to see such a difference. I imagine there are some obvious explanations for this if I understood the lower level components more, but it’s funny because I often joke about how bad javascript is at math :shrugz:

     #!/usr/bin/env perl use warnings; use strict; use Scalar::Util qw(looks_like_number); use Time::HiRes qw(gettimeofday tv_interval); sub isPrime { my ( $input ) = @_; return if ( !looks_like_number($input) || $input < 2 || ($input != 2 && $input % 2 == 0) ); for (my $chkval = 3; $chkval < $input; $chkval++) { return if ($input % $chkval == 0); } return 1; } sub getNextPrime { my ( $start ) = @_; $start = 1 if (!$start || !looks_like_number($start)); my $prime; do { $prime = $start if (isPrime(++$start)); } while (!$prime); return $prime; } sub findPrimes { my ( $count ) = @_; my @primes; while ($#primes + 1 < $count) { push(@primes, getNextPrime($primes[@primes - 1])); } return @primes; } my $t0 = [gettimeofday()]; my @primes = findPrimes(@ARGV); my $primes = @primes; my $elapsed = tv_interval($t0); print "Found {$primes} primes in $elapsed seconds with the largest prime = {$primes[@primes - 1]}";
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 20:05:43 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     @kkarhan I guess essentially that's what I'm doing but at this point I'm comparing languages. Working out a python version now to see how python stacks up. Keeping the logic more or less the same just for comparison.
   • Kevin Karhan :verified: (kkarhan@mstdn.social)'s status on Saturday, 25-Mar-2023 20:05:44 JST Kevin Karhan :verified:

     in reply to

     @thatguyoverthere well, Chris #Barnatt just uses sysbench 0.4.12 to compare computational power by making it factor all primes up to 10.000 and then looking how long that tool.

     https://www.youtube.com/watch?v=51OMXTElStM&t=644s

     Disinformation Purveyor :verified_think: likes this.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Saturday, 25-Mar-2023 20:22:43 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     @kkarhan on the phone the perl takes almost a minute and a half... Three times as long as the laptop.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Sunday, 26-Mar-2023 21:32:16 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     @kkarhan so I found that I wasn't skipping even numbers in my perl version which hurt performance. I also wrote a python and c version because I think the differences in the languages are interesting.
     
     On my laptop 10k primes in C, JavaScript, Perl, and Python take:
     
     C: ~0.75 seconds
     JavaScript: ~1.15 seconds
     Perl: ~16 seconds
     Python: > 20 seconds
     
     I didn't bother doing 100k with python or perl, but with C 100k is complete in about 90 seconds and javascript takes about another minute.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Sunday, 26-Mar-2023 23:36:46 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @not_br549 @kkarhan coulda/shoulda done 3 and 5 too... definitely would speed it up. My first pass was horrendous. to test a single value I created a full array from 1 - x and worked backwards checking every value. It was probably the least efficient way to search for primes haha.
     
     I know it's not a particularly productive use of my time, but it has been fun to see how different the languages are. My first pass with C was also not skipping even numbers and was slower than the javascript which truly broke my brain for a few minutes while I worked out what I had done wrong. I knew it was impossible for javascript to be faster so the problem had to be with me. It still surprises me that python and perl are slower than javascript with primes.
   • Jolly Rancher (not_br549@jollyville.net)'s status on Sunday, 26-Mar-2023 23:36:47 JST Jolly Rancher

     in reply to

     • Kevin Karhan :verified:
     Interesting thread. In 1963 or so, I wrote a sieve for the 1620 in machine language. As I recall, I skipped multiples of 2, 3, and 5 and only tested divisors up to sqrt( x ). It only had 60K of storage, so the array was limited . . . the program hadn't hit its limit but after about a half hour another student came in and wanted to run something else. The largest prime it printed was 15551.
     Was fun to watch the blinkenlights as it struggled with long division.
     Disinformation Purveyor :verified_think: likes this.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Sunday, 26-Mar-2023 23:40:47 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @not_br549 @kkarhan modern computers allow me to suck at math and reach much higher primes lol
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Sunday, 26-Mar-2023 23:44:48 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @not_br549 @kkarhan so I just excluded multiples of 3 and 5 and at least with regard to the first 100k primes there was no noticeable improvement in the time :Thinker:
     
     97 seconds with skipping multiples of 2 and 97 seconds skipping multiples of 2,3,5
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Sunday, 26-Mar-2023 23:49:06 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @kkarhan @not_br549 I guess when you consider that half of the multiples of 3 and 5 are evens and already excluded (and there is overlap in those sets as well) you probably need to get to pretty big numbers before it starts to make a big difference.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Sunday, 26-Mar-2023 23:51:12 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @kkarhan @not_br549 in perl I did manage to shave a second off
   • Jolly Rancher (not_br549@jollyville.net)'s status on Sunday, 26-Mar-2023 23:52:52 JST Jolly Rancher

     in reply to

     • Kevin Karhan :verified:
     the school had a System 360 in another room that it used for school business, records, accounting, etc. the 360 was an order of magnitude faster and more capable, but the 1620 was fun to play with.
     the contrast with a modern laptop or phone, running an interpreted language with all its backing and forthing overhead, and your quick-and-dirty sieve tearing down the array with every iteration, was interesting.
     Disinformation Purveyor :verified_think: likes this.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Sunday, 26-Mar-2023 23:56:03 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @not_br549 @kkarhan yeah I find these things quite interesting. I am tempted to compile the c program for the phone and give it a go to see how well the compiled c does on the phone compared to the interpreted javascript. the fact that javascript is interpreted and still isn't too far off from C speeds (in these lower values) is pretty amazing, and the fact that it ran so much faster on the phone (still using nodejs rather than a browser interpreter) makes me curious what the actual differences are that make the arm proc so much better at this specific task.
   • Jolly Rancher (not_br549@jollyville.net)'s status on Sunday, 26-Mar-2023 23:56:15 JST Jolly Rancher

     in reply to

     • Kevin Karhan :verified:
     of course, the advantage of modern languages is that you can make that program change in a minute or less, and try it. back then, I would have to struggle for a day redoing branch target addresses, etc, etc..
     Disinformation Purveyor :verified_think: likes this.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Sunday, 26-Mar-2023 23:58:42 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @not_br549 @kkarhan Oh I can only imagine. One of the things I tell people who are showing interest in programming or some other computer related field is that the ability to make so many mistakes so quickly and cheaply (and often safely) makes iterative learning more fun.
   • Kevin Karhan :verified: (kkarhan@mstdn.social)'s status on Monday, 27-Mar-2023 00:22:31 JST Kevin Karhan :verified:

     in reply to

     • Jolly Rancher

     @not_br549 @thatguyoverthere lession of it:

     Buy your kid a (used) mainframe to boost the career straight into #IBM:
     https://m.youtube.com/watch?v=wJyiHsfJLEI

     Disinformation Purveyor :verified_think: likes this.
   • Kevin Karhan :verified: (kkarhan@mstdn.social)'s status on Monday, 27-Mar-2023 00:22:32 JST Kevin Karhan :verified:

     in reply to

     • Jolly Rancher

     @not_br549 @thatguyoverthere
     Reminds me of that story.
     https://m.youtube.com/watch?v=45X4VP8CGtk

     Disinformation Purveyor :verified_think: likes this.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Monday, 27-Mar-2023 00:35:55 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @kkarhan @not_br549 on the phone's arm processor the c program completed in 70 seconds (~17 seconds faster) with 100k primes. I used clang to compile on the phone and gcc to compile on the laptop.
   • Kevin Karhan :verified: (kkarhan@mstdn.social)'s status on Monday, 27-Mar-2023 00:36:02 JST Kevin Karhan :verified:

     in reply to

     • Jolly Rancher

     @thatguyoverthere @not_br549 not to mention that there are several options to do the same based off "quick and dirty" (Python), "Quick & Cheap" (bash), "Portable" (Java), "Academic" (C / C++) or "Maximum Efficiency above everything else" (Assembly)...

     Disinformation Purveyor :verified_think: likes this.
   • Disinformation Purveyor :verified_think: (thatguyoverthere@shitposter.club)'s status on Monday, 27-Mar-2023 02:42:39 JST Disinformation Purveyor :verified_think:

     in reply to

     • Kevin Karhan :verified:
     • Jolly Rancher
     @kkarhan @not_br549 you mean the newly initialized array each iteration? I mean it works but it isn't terribly efficient. A for loop has to be better right? You just increment an integer each loop iteration instead of having to claim and release a bunch of memory for the array.
   • Kevin Karhan :verified: (kkarhan@mstdn.social)'s status on Monday, 27-Mar-2023 02:42:40 JST Kevin Karhan :verified:

     in reply to

     • Jolly Rancher

     @thatguyoverthere @not_br549 it's the way I learned to do it in C tho.