Join devRant
Do all the things like
++ or  rants, post your own rants, comment on others' rants and build your customized dev avatar
Sign Up
Pipeless API
From the creators of devRant, Pipeless lets you power realtime personalized recommendations and activity feeds using a simple API
Learn More
Search  "generator"

Two big moments today:
1. Holy hell, how did I ever get on without a proper debugger? Was debugging some old code by eye (following along and keeping track mentally, of what the variables should be and what each step did). That didn't work because the code isn't intuitive. Tried the print() method, old reliable as it were. Kinda worked but didn't give me enough finegrain control.
Bit the bullet and installed Wing IDE for python. And bam, it hit me. How did I ever live without stepthrough, and breakpoints before now?
2. Remember that nonsieve prime generator I wrote a while back? (well maybe some of you do). The one that generated quasi lucas carmichael (QLC) numbers? Well thats what I managed to debug. I figured out why it wasn't working. Last time I released it, I included two core methods, genprimes() and nextPrime(). The first generates a list of primes accurately, up to some n, and only needs a small handful of QLC numbers filtered out after the fact (because the set of primes generated and the set of QLC numbers overlap. Well I think they call it an embedding, as in QLC is included in the series generated by genprimes, but not the converse, but I digress).
nextPrime() was supposed to take any arbitrary n above zero, and accurately return the nearest prime number above the argument. But for some reason when it started, it would return 2,3,5,6...but genprimes() would work fine for some reason.
So genprimes loops over an index, i, and tests it for primality. It begins by entering the loop, and doing "result = gffi(i)".
This calls into something a function that runs four tests on the argument passed to it. I won't go into detail here about what those are because I don't even remember how I came up with them (I'll make a separate post when the code is fully fixed).
If the number fails any of these tests then gffi would just return the value of i that was passed to it, unaltered. Otherwise, if it did pass all of them, it would return i+1.
And once back in genPrimes() we would check if the variable 'result' was greater than the loop index. And if it was, then it was either prime (comparatively plentiful) or a QLC number (comparatively rare)these two types and no others.
nextPrime() was only taking n, and didn't have this index to compare to, so the prior steps in genprimes were acting as a filter that nextPrime() didn't have, while internally gffi() was returning not only primes, and QLCs, but also plenty of composite numbers.
Now *why* that last step in genPrimes() was filtering out all the composites, idk.
But now that I understand whats going on I can fix it and hypothetically it should be possible to enter a positive n of any size, and without additional primality checks (such as is done with sieves, where you have to check off multiples of n), get the nearest prime numbers. Of course I'm not familiar enough with prime number generation to know if thats an achievement or worthwhile mentioning, so if anyone *is* familiar, and how something like that holds up compared to other linear generators (O(n)?), I'd be interested to hear about it.
I also am working on filtering out the intersection of the sets (QLC numbers), which I'm pretty sure I figured out how to incorporate into the prime generator itself.
I also think it may be possible to generator primes even faster, using the carmichael numbers or related setor even derive a function that maps one set of upperandlower bounds around a semiprime, and map those same bounds to carmichael numbers that act as the upper and lower bound numbers on the factors of a semiprime.
Meanwhile I'm also looking into testing the prime generator on a larger set of numbers (to make sure it doesn't fail at large values of n) and so I'm looking for more computing power if anyone has it on hand, or is willing to test it at sufficiently large bit lengths (512, 1024, etc).
Lastly, the earlier work I posted (linked below), I realized could be applied with ECM to greatly reduce the smallest factor of a large number.
If ECM, being one of the best methods available, only handles 5060 digit numbers, & your factors are 70+ digits, then being able to transform your semiprime product into another product tree thats nonsemiprime, with factors that ARE in range of ECM, and which *does* contain either of the original factors, means products that *were not* formally factorable by ECM, *could* be now.
That wouldn't have been possible though withput enormous help from many others such as hitko who took the time to explain the solution was a form of modular exponentiation, FastNop who contributed on other threads, Voxera who did as well, and support from Scor in particular, and many others.
Thank you all. And more to come.
Links mentioned (because DR wouldn't accept them as they were):
https://pastebin.com/MWechZj912 
I am so sick and tired of hearing “AI” everywhere all the time. Yeah how about we integrate some AI into your super smart toaster so that it knows when to start preparing for when you put toasts in it in the morning.
Not even mentioning all these idiots being like “oh yeah AI is becoming sentient. Oh yeah AI is gonna take over the world”.
Brother the current state of AI is just machine learning, it’s a stupid pattern detector and generator it doesn’t have thoughts, emotions. Please just stop it.6 
New project team name needed
Random team name generator suggested "The snowballers"
Errrr no I don't think so 🤢
https://urbandictionary.com/define....4 
I just compiled a color palette for devRantrelated drawings that anyone can import into GIMP and Inkscape. Already successfully using it for graphics promoting dR Community Matrix (more on that later), hence the name: "drcmpalette".
🎨 https://github.com/drcmatrix/...
For reference I used colors produced by "Tailwind CSS 10color Palette Generator": https://tailwind.simeongriggs.dev/19 
It powers nodejs.org. It has 7.8k stars on Github.
It was installed 5x as much on NPM in the last 4 months as it was in the previous 5 years. https://metalsmith.io
I've been doing a lot of outreach to individual users, websites, and related Github projects, yet community involvement is hard to get by. If you value copyleft or free opensource software and are interested in bloatfree nodejs static site generation or build pipelines, please reach out.
I have a fulltime job and am thankful for any help, be it feedback on the Gitter chat: https://gitter.im/metalsmith/... maintaining one of the 15+ core plugins, creating starters or writing blog posts.1 
What you could have:
 simple project structure
 common lib with modular logic
 import logic as needed in you services
What you do:
 waste months to write an opinionated framework that works only if used in a super specific way
 have a fat sample project as example
 use a code generator to copy and rename the said sample project whenever you create a new service
 have everything break whenever something new is added in the framework
 oh and keep the framework in active development while others work on the client services, so lots of things will break often and out of nowhere
Fucking god, i hate when people make pet projects out of work projects2 
So I think my dumbest project so far was when I created a pseudorandom number generator which instead of using some proper source of randomness used freaking Minecraft Villagers.
I wrote a blog post on it, so feel free to take a look there to see how I did it and perhaps learn something about randomness.
Blog post: https://adampisula.pizza/posts/...4 
Found a clever little algorithm for computing the product of all primes between nm without recomputing them.
We'll start with the product of all primes up to some n.
so [2, 2*3, 2*3*5, 2*3*5*,7..] etc
prods = []
i = 0
total = 1
while i < 100:
....total = total*primes[i]
....prods.append(total)
....i = i + 1
Terrible variable names, can't be arsed at the moment.
The result is a list with the values
2, 6, 30, 210, 2310, 30030, etc.
Now assume you have two factors,with indexes i, and j, where j>i
You can calculate the gap between the two corresponding primes easily.
A gap is defined at the product of all primes that fall between the prime indexes i and j.
To calculate the gap between any two primes, merely look up their index, and then do..
prods[j1]/prods[i]
That is the product of all primes between the J'th prime and the I'th prime
To get the product of all primes *under* i, you can simply look it up like so:
prods[i1]
Incidentally, finding a number n that is equivalent to (prods[j+i]/prods[ji]) for any *possible* value of j and i (regardless of whether you precomputed n from the list generator for prods, or simply iterated n=n+1 fashion), is equivalent to finding an algorithm for generating all prime numbers under n.
Hypothetically you could pick a number N out of a hat, thats a thousand digits long, and it happens to be the product of all primes underneath it.
You could then start generating primes by doing
i = 3
while i < N:
....if (N/k)%1 == 0:
........factors.append(N/k)
....i=i+1
The only caveat is that there should be more false solutions as real ones. In otherwords theres no telling if you found a solution N corresponding to some value of (prods[j+i]/prods[ji]) without testing the primality of *all* values of k under N.12 
In the 90s most people had touched grass, but few touched a computer.
In the 2090s most people will have touched a computer, but not grass.
But at least we'll have fully sentient dildos armed with laser guns to mildly stimulate our mandatory attached cyberclits, or alternatively annihilate thought criminals.
In other news my prime generator has exhaustively been checked against, all primes from 5 to 1 million. I used millerrabin with k=40 to confirm the results.
The set the generator creates is the join of the quasilucas carmichael numbers, the carmichael numbers, and the primes. So after I generated a number I just had to treat those numbers as 'pollutants' and filter them out, which was dead simple.
Whats left after filtering, is strictly the primes.
I also tested it randomly on 5055 bit primes, and it always returned true, but that range hasn't been fully tested so far because it takes 912 seconds per number at that point.
I was expecting maybe a few failures by my generator. So what I did was I wrote a function, genMillerTest(), and all it does is take some number n, returns the next prime after it (using my functions nextPrime() and isPrime()), and then tests it against millerrabin. If miller returns false, then I add the result to a list. And then I check *those* results by hand (because miller can occasionally return false positives, though I'm not familiar enough with the math to know how often).
Well, imagine my surprise when I had zero false positives.
Which means either my code is generating the same exact set as miller (under some very large value of n), or the chance of miller (at k=40 tests) returning a false positive is vanishingly small.
My next steps should be to parallelize the checking process, and set up my other desktop to run those tests continuously.
Concurrently I should work on figuring out why my slowest primality tests (theres six of them, though I think I can eliminate two) are so slow and if I can better estimate or derive a pattern that allows faster results by better initialization of the variables used by these tests.
I already wrote some cases to output which tests most frequently succeeded (if any of them pass, then the number isn't prime), and therefore could cut short the primality test of a number. I rewrote the function to put those tests in order from most likely to least likely.
I'm also thinking that there may be some clues for faster computation in other bases, or perhaps in binary, or inspecting the patterns of values in the natural logs of nonprimes versus primes. Or even looking into the *execution* time of numbers that successfully pass as prime versus ones that don't. Theres a bevy of possible approaches.
The entire process for the first 1_000_000 numbers, ran 1621.28 seconds, or just shy of a tenth of a second per test but I'm sure thats biased toward the head of the list.
If theres any other approach or ideas I may be overlooking, I wouldn't know where to begin.16 
The first fruits of almost five years of labor:
7.8% of semiprimes give the magnitude of their lowest prime factor via the following equation:
((p/(((((p/(10**(Mag(p)1))).sqrt())x) + x)*w))/10)
I've also learned, given exponents of some variables, to relate other variables to them on a curve to better sense make of the larger algebraic structure. This has mostly been stumbling in the dark but after a while it has become easier to translate these into methods that allow plugging in one known variable to derive an unknown in a series of products.
For example I have a series of variables d4a, d4u, d4z, d4omega, etc, and these are translateable now, through insights that become various methods, into other types of (nond4) series. What these variables actually represent is less relevant, only that it is possible to translate between them.
I've been doing some initial learning about neural nets (implementation, rather than theoretics as I normally read about). I'm thinking what I might do is build a GPT style sequence generator, and train it on the 'unknowns' from semiprime products with known factors.
The whole point of the project is that a bunch of internal variables can easily be derived, (d4a, c/d4, u*v) from a product, its root, and its mantissa, that relate to *unknown* variablesunknown variables such as u, v, c, and d4, that if known directly give a constant time answer to the factors of the original product.
I think theres sufficient data at this point to train such a machine, I just don't think I'm up to it yet because I'm lacking in the calculus department.
2000+ variables that are derivable from a product, without knowing its factors, which are themselves products of unknown variables derived from the internal algebraic relations of a productthis ought to be enough of an attack surface to do something with.
I'm willing to collaborate with someone familiar with recurrent neural nets and get them up to speed through telegram/element/discord if they're willing to do the setup and training for a neural net of this sort, one that can tease out hidden relationships and map known variables to the unknown set for a given product.16 
I just spent 4 (four) hours debugging why my perlin noise used the same gradient for every point. Turns out I forgot to assign the seed for the random generator so it defaulted to 0. (I seed it every round with the map seed and coordinates so I don't have to store anything for visited regions)
So, how's your sunday night going? 
I'm learning Rust as a case study for my own programming language. It's funny how many approaches exist to the humble loop.
 In classic procedural languages, a loop's job is to repeat actions, and as such it provides a multitude of tools to control this repetition.
 In all languages with iterators, a forin loop is a construct that does something with every element of a collection. In languages with both iterators and generator functions, this can even be used to define a sequence in terms of another.
 In Rust, a loop is an expression that obtains its value through repeated execution. It can also be used like a classic loop, of course, but this is the interesting part.
 My little language is a functional language, so "loop" is the Y combinator. To loop means to define the value of an expression in terms of itself. It's the only looping construct, gets special treatment from the type checker and it's also used in recursive type definitions. 
Kinda often, the ecosystem around C/C++ kinda sucks
Compilers will give you hieroglyphs instead of readable errors.
Including a separate library, or a code generator, into your project is generally hell on earth to set up.
The language server often needs several seconds to come up with suggestions, some of which are complete nonsense.
The language itself lacks many basic features. C++20 will give us so many fancy things but we still can't convert an enum to a string.
I've programmed in C# and lately in Rust, and damn the developer experience there is just so much nicer overall.31 
Up all damn night making the script work.
Wrote a nonsieve prime generator.
Thing kept outputting one or two numbers that weren't prime, related to something called carmichael numbers.
Any case got it to work, god damn was it a slog though.
Generates next and previous primes pretty reliably regardless of the size of the number
(haven't gone over 31 bit because I haven't had a chance to implement decimal for this).
Don't know if the sieve is the only reliable way to do it. This seems to do it without a hitch, and doesn't seem to use a lot of memory. Don't have to constantly return to a lookup table of small factors or their multiple either.
Technically it generates the primes out of the integers, and not the other way around.
Things 0.010.02th of a second per prime up to around the 100 million mark, and then it gets into the 0.151second range per generation.
At around primes of a couple billion, its averaging about 1 second per bit to calculate 1. whether the number is prime or not, 2. what the next or last immediate prime is. Although I'm sure theres some optimization or improvement here.
Seems reliable but obviously I don't have the resources to check it beyond the first 20k primes I confirmed.
From what I can see it didn't drop any primes, and it didn't include any errant nonprimes.
Codes here:
https://pastebin.com/raw/57j3mHsN
Your gotos should be nextPrime(), lastPrime(), isPrime, genPrimes(up to but not including some N), and genNPrimes(), which generates x amount of primes for you.
Speed limit definitely seems to top out at 1 second per bit for a prime once the code is in the billions, but I don't know if thats the ceiling, again, because decimal needs implemented.
I think the core method, in calcY (terrible name, I know) could probably be optimized in some clever way if its given an adjacent prime, and what parameters were used. Theres probably some pattern I'm not seeing, but eh.
I'm also wondering if I can't use those fancy aberrations, 'carmichael numbers' or whatever the hell they are, to calculate some sort of offset, and by doing so, figure out a given primes index.
And all my brain says is "sleep"
But family wants me to hang out, and I have to go talk a manager at home depot into an interview, because wanting to program for a living, and actually getting someone to give you the time of day are two different things.1 
Anyone here use generator functions in JS? Seems like it could be useful but whenever I explore the possibility of using one, I usually end up going another route9

Finally got around to turning the newssection generator markdown / deno thingy into a GitHub Action!
https://github.com/MarkedDown/News
Haven't finished writing the documentation though. 
Thinking of coding an interview question generator. Could be a good way to study AI by training it to make asinine sentences.
If Jimmy has 2 arms and 2 legs, what is the maiden name of his mom?2 
I don't know if this counts but wrote a generator that replaced a shitty linq to sql dal to use our system so I didn't have to mess with a web app I'd written. In place replacement with a few methods that made the other transaction lock field updates and calls etc
Most risky I can think of
Everything else was data migrations but there were always backups1 
Utility libraries, because I actually get to see my life improve because I have them. Creating new projects becomes easier because I put parts I reuse somewhere else.
There was an old config file generator/manager I kept using for a while, some string conversion libraries between formats, some REST/WebRTC API wrappers, I have a web audio API I create tunes with in various projects. CI/CD scripts for laziness so I never have to know how to set anything up again. Lately the thing I'm most happy about is I turned some free text saving service into a makeshift database and it's been working well for about half a dozen projects now. Wouldn't handle large amount of users but can't beat free and easy.
I also find merit in prototypes/old projects, because I can reference random things I did in them in newer unrelated projects. Things too small to warrant their own utility library, argh! 
Wanted a change from work and decided to make a small news ( styled markdown ) generator after talking to a PulsarEdit maintainer.
https://github.com/pulsaredit/...1 
Lately been doing a lot of GitHub action stuff so created a Yeoman generator to scaffold javascriptbased Github actions.
You can check the project here if you want 🦄
https://github.com/RocktimSaikia/... 
Some senior just pushed some half assed typescript code generator that generates stupid types that make everyone's life difficult.
Who need transparent type inference? Just use type guard everywhere.
Can't reason with the particular individual.
Please release me from my misery.
In house built == shitty version of original open source library. 
Is there any tool that generates an eslint config interactively? E.g. I would start off with airbnb style (but not required) and then toggle different options and see what changes and what will be highlighted. In the end I can save the config. I know eclipse provides such a wizard for java, but haven't found an equivalent one for JS/TS. Anything better than ESLint playground?1