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  ""math""

These "math question" captchas are really stupid.
It's not even an image that has to be OCRed, it's just plaintext. Why can't these people understand a captcha is supposed to be something only a person can do? This is math. Computers are amazing at math.23 
Math teacher: 1+1=?
Me: one zero
Math teacher: wrong!
So i gived to her my calculator (in binary mode :) )
Me: check the answer.
Math teacher: [saw 1+1=10 on calc] thinks about 10 seconds LOL then says: you calculator is broken!18 
When you're thinking about your code when doing math homework, but then realize you're accidentally putting semicolons after each step.97

Math: the imaginary unit is i.
Electrical engineering: no, it's j.
C hacker: hands off my loop variables!13 
Day 1:
I installed an alarm app that doesn't turn off until you solve some math problem.
Next morning:
* alarm turns on
* solve the math problem
* get back to sleep
Conclusion:
most dangerous thing in the morning is the " let me close my eyes for one second"9 
That moment when you realise f(x)=x²
that you did in 4th grade and now
Function(x){
return x*x;
}
....😯😮😲😱😵...
You realise that Everyone has been doing programming all their life....6 
Basic math class for devvys
Lemme prove that 2 = 1
a = b
a^2 = ab
a^2  b^2 = ab  b^2
(a + b) (a  b) = b (a  b)
a + b = b
b + b = b
2b = b
2 = 1
Find a place where I got wrong...
And if you fall by this, you should go to preschool again18 
Been telling relatives that I'm an applied math major to get out of helping them with their tech issues.3

A friend just asked if I could get him an internship at the place I work. He has no computer/programming background at all but how hard could developing be.
So I informed him my CS degree required at least 7 math courses lowest being calculus.
You need to know math!?!?
Yeah we're the one who writes the programs that actually does the math for everyone else9 
At a job interview.
Them: Can you please write a function that calculates fibonacci numbers on the whiteboard please.
Me:
fib=_=>($=>$.round(($.pow((1+$.sqrt(5))/2,_)$.pow(2/(1+$.sqrt(5)),_))/$.sqrt(5)))(Math)18 
Hardcore loli porn.
Just kiddig. Video games and math study. I believe that the most elegant solutions come in the form of math and the challenge they impose as well as the satisfaction of getting the correct result (or the estimate for it) are comparable to running a succesfull application.11 
math be like:
"Addition (often signified by the plus symbol "+") is one of the four basic operations of arithmetic; the others are subtraction, multiplication and division. The addition of two whole numbers is the total amount of those values combined. For example, in the adjacent picture, there is a combination of three apples and two apples together, making a total of five apples. This observation is equivalent to the mathematical expression "3 + 2 = 5" i.e., "3 add 2 is equal to 5".
Besides counting items, addition can also be defined on other types of numbers, such as integers, real numbers and complex numbers. This is part of arithmetic, a branch of mathematics. In algebra, another area of mathematics, addition can be performed on abstract objects such as vectors and matrices.
Addition has several important properties. It is commutative, meaning that order does not matter, and it is associative, meaning that when one adds more than two numbers, the order in which addition is performed does not matter (see Summation). Repeated addition of 1 is the same as counting; addition of 0 does not change a number. Addition also obeys predictable rules concerning related operations such as subtraction and multiplication.
Performing addition is one of the simplest numerical tasks. Addition of very small numbers is accessible to toddlers; the most basic task, 1 + 1, can be performed by infants as young as five months and even some members of other animal species. In primary education, students are taught to add numbers in the decimal system, starting with single digits and progressively tackling more difficult problems. Mechanical aids range from the ancient abacus to the modern computer, where research on the most efficient implementations of addition continues to this day."
And you think like .. easy, but then you turn the page:17 
I’ve realized that programming made me so much better at math!
Although I’ve caught myself writing “int x” once in the notebook.1 
Mother fucking SQL, fuck mathematicians, fuck every thing!
So let's supose we'd only need the first char of a string. Every, and I mean fucking every (php, java, javascript, ruby, python, haskell) fucking language, uses something like `substring(input, 0, 1)` as it knows the input is nothing more than a fucking array of chars, otherwise known as motherfucking String. Logically the offset for the first char is 0.
Enter SQL, there you need to put `SUBSTRING(input, 1, 1)` because fuck every one! Fucking math guys who developed relational algebra on which (most) databases are based on (I love you for it, but come on you fuckers!), Decided that the first character should be at position 1...
Fuckers6 
The state of informatics education is just saddening.
You study "Software Development" and then you get to do exams asking you to do some basic linux commands  with full internet access on a computer. People are allowed to fail this and study on. On the other hand you have to do real coding with pen and paper, have to calculate from hex to bin to dec and stuff and most Importantly  know about all kinds of math stuff completely unreleated to cs.
Graph Theory absolutely makes sense in my eyes, but not if it's plain fucken math without even mentioning computers or applications of it. But if you fail that everyone looks weird at you.
I know about coding. I got A's and B's in all the coding exams _without even doing much for them_ but then fail all the fucken math exams. Makes no sense. FML.8 
Everyday, I am amazed at developers like those here on devRant. I look up at you in awe and admiration, always thinking about how awesome your life probably is, even though you rant about it sometimes. I want to be like many of you in the future.
Thank you for improving our lives with whatever you are doing. I feel like this doesn't get said enough.
Meanwhile, University sucks (failed exams), but I am expected to graduate with good grades. Sigh. I also feel like I'm not learning enough of those things that I need to become a good dev and rather overly complicated math which I'll never need in my later life.24 
Well, I just learned how much of a pain it is to learn the math for learning neural networks. I really should have paid more attention in high school.
I will learn, the hard way I guess...6 
Honestly, i hate math or actually i hate that i suck at it. I graduated CS and if u put a math problem any bit more advanced than basic linear equations i will turn red. I wish i was good at it. I think if i was, id be able to do much more cool shit because combining math and the ability to control a computer basically makes you a demi god.
If i had some free time i’d love to go over the basics on khan academy or something. But free time doesnt come by a lot coz we’re too busy trying to make money and id rather just rest and chill when it does.
Tho if a cute girl offered to tutor me in that free time i’d definitely say yes 🧐15 
Me in school: Math? When do I need know those details? I can look them up and just code it.
Me in high school: Computer science is way too mathy. I want to code!
Me coding php: Just make it work.
Me coding typescript: Just make it work.
Me coding scala: Just make it ... what ... how do I make it work!?!
Me asking stackoverflow: How do I do X in scala some functional programming stuff in mind in order to keep immutability.
Somebody way smarter than I: "In scalaz, a function A => A is called an endomorphism and is a Monoid whose associative binary operation is function composition and whose identity is the identity function"
Me now: Fuck my old arrogant self.1 
Fully Homomorphic Encryption (computing addition and multiplication of numbers WITHOUT decrypting) is fucking cool. That is all.
https://bitml.github.io/blog/post/...15 
Skills required for ML :
Math skills:
====================
Programming skills :
===
Skills required for ML with GPU:
Math skills:
====================
Programming skills :
====================
/*contemplating career choice*/
: /3 
Discrete mathematics teacher said "13*37" in the middle of an Euclidean algorithm.
Half the class giggled and the other half just sighed.
These students are your future coworkers.2 
Take more math than you need. Seriously. Computers are made of math. Nobody ever got an award for best looking web page. People do get awards for actual science.4

Remember the post about bruce's constant?(4.5099806905005)
Well apparently theres a convergent series for it found all the way back in 2015.
Apparently its an actual thing. Which connects e to the square root of this series.
And it converges on (bruce1)**0.5.
I confirmed it myself.
The two people who found the series that converges are N. J. A. Sloane and Hiroaki Yamanouchi
Thank you Sloane and Hiroaki!
The actual formula is a series of embedded square roots with the repeating numbers 1,4,2,8,5,7
like so...
sqrt(1+sqrt(4+sqrt(2+sqrt(8+sqrt...
What this means is you can find e using this series.
All you do is run the series, raise by a power of 2, add 1, calculate J and K like so
J = log(2, 1.333333333333333) / log(2, 2)
K = log(2, 1.333333333333333) / log(2, 3)
then calculate (J+K)(bruce1)
and out pops our buddy e:
2.7182818284591317
I guess I bullshitted myself for so long, that I didn't believe people like scor when they said they legit witnessed by math skills grow.
Or maybe a blind squirrel occasionally DOES find a nut.
Pretty cool find either way.13 
Status update: Almost two months ago I struggled alot with even basic math.
Now I've gotten way better in not just basic stuff, but also college level of math.
That's it. Bye.5 
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 
*Didnt understand anything mathematic back in grade and highschool
*Can understand math in code no problem.4 
I feel like I've ranted this before. many times. but here we go again because Australia.
why do people think you can just ban math? like really?! that's what crypto laws do. they require companies to use shitty math. and what prevents me from using the good math? nothing! oh I mean... I won't use it? scouts honor.
you can't ban math.
literally billions of internet users don't fall in your jurisdiction.
no single jurisdiction can cover more than a subset of the internet.
I will use whatever maths I damn well please.
fuck off. please stop making us less safe.
/discussion5 
Wow, I still remember some math after decades. Today, I needed some parameter calculation in an interval with smooth transition at both ends (i.e. continuously differentiable). So I used a 3rd degree polynomial where the values and derivations gave a 4x4 linear equation system. I lazily hacked that into WolframAlpha, and it works nicely.1

A new mathematical constant was discovered recently: Bruce's constant
I took some code from the paper and adapted it in python.
def bruce(n):
J = log(n, 1.333333333333333) / log(n, 2)
K = log(n, 1.333333333333333) / log(n, 3)
return ((J+K)e)+1
gives e everytime for ((J+K)bruce)+1, regardless of the value of n.
bruce can always be aproximated with the decimal 4.5, telling you how close n can be used to aproximate e (usually to two digits).
Bruce's constant is equal to 4.5099806905005
It is named after that famous mathematician, bruce lee.
You'll start with four limbs and end up with two in a wheelchair!6 
Upon reflection, I think that the amount of math I learned in school pales in comparison to the amount I learned about LaTeX. I could pretty reliably recreate the textbook rendition of the problem. Maybe it's just me but just knowing the solution felt too abstract. I want a solid looking execution of it.
I'm graduating today so I don't know how relatable this is for everyone else. I'm just reflecting.3 
Read "How to implement a programming language" (http://lisperator.net/pltut) and it was very cool and enlightening. I have decided to use what I learned to make a math evaluator with a proper lexer and extensible library and stuff like that. Not a full programming language but a nice and advanced math evaluator.10

I've got a teacher (math) in the university that let us use our phones as a calculator in the exam but without sim card and of course no wifi. I've spent a few hours programming a very ugly CLI app which let me calc and show me the steps of every type of exercise.
Another probe that programming can save your ass.
The exam wasn't difficult but basically they tell you to solve a few problems applying different methods, that hasn't advantage from others.8 
Apparently, floating point math is broken.
=SUM((2.1  2.0)  0.1)
In PHP and Haskell this also happens10 
Got a mathematics library I develop and maintain. Someone filed a feature request ticket for matrices of matrices. As in, each value of the primary matrix is another matrix. Not understanding why anyone would need such a convoluted concept, I asked for clarification.
Response: "This piece of shit library isn't feature complete without it, now stop being a lazy fag in your mother's basement and actually do something"
Lololololol. Sure thing. Let me go waste two or more weeks of my life developing something i've never seen used in math, without any justification beyond "feature".4 
1. Building stuff is awesome!
2. It's creative work that actually makes cash
3. I like writing algos and math4 
I have this math teacher and, wow, is she good at math. And, wow, should she never enter another field in her life. Today she asked us if anyone does code. The answer is yes, but I refuse to answer something that uses code as a verb.7

Those of you who like "The Imitation Game", you probably want to check out "Hidden Figures" (2016). It's on Netflix now.
About a team of female AfricanAmerican mathematicians who wanted to "break the glass ceiling" in NASA.
 Dorothy : conquered the (recently acquired) IBM frameworks using Fortran and taught her team to program it
 Mary : appealed to court to be allowed to study in a allwhite school to get her qualification to be an aerospace engineer
 Katherine : her skills in analytical geometry enabled her to be the first female AfricanAmerican in the Space Task Group in calculating the momentous capsule launch into orbit
My lazy ass just can't fathom how someone who deals with so much math and pressure can still smile to their family after work. My grumpiness nature will surely turn me into a monster.
And now I know what "human computers" means.5 
Still on the primenumbers bender.
Had this idea that if there were subtle correlations between a sufficiently large set of identities and the digits of a prime number, the best way to find it would be to automate the search.
And thats just what I did.
I started with trace matrices.
I actually didn't expect much of it. I was hoping I'd at least get lucky with a few chance coincidences.
My first tests failed miserably. Eight percent here, 10% there. "I might as well just pick a number out of a hat!" I thought.
I scaled it way back and asked if it was possible to predict *just* the first digit of either of the prime factors.
That also failed. Prediction rates were low still. Like 0.080.15.
So I automated *that*.
After a couple days of onandoff again semiautomated searching I stumbled on it.
[1144, 827, 326, 1184, 1, 1, 1, 1]
That little sequence is a series of identities representing different values derived from a randomly generated product.
Each slots into a trace matrice. The results of which predict the first digit of one of our factors, with a 83.2% accuracy even after 10k runs, and rising higher with the number of trials.
It's not much, but I was kind of proud of it.
I'm pushing for finding 90%+ now.
Some improvements include using a different sort of operation to generate results. Or logging all results and finding the digit within each result thats *most* likely to predict our targets, across all results. (right now I just take the digit in the ones column, which works but is an arbitrary decision on my part).
Theres also the fact that it's trivial to correctly guess the digit 25% of the time, simply by guessing 1, 3, 7, or 9, because all primes, except for 2, end in one of these four.
I have also yet to find a trace with a specific bias for predicting either the smaller of two unique factors *or* the larger. But I haven't really looked for one either.
I still need to write a generate that takes specific traces, and lets me mutate some of the values, to push them towards certain 'fitness' levels.
This would be useful not just for very high predictions, but to find traces with very *low* predictions.
Why? Because it would actually allow for the *elimination* of possible digits, much like sudoku, from a given place value in a predicted factor.
I don't know if any of this will even end up working past the first digit. But splitting the odds, between the two unique factors of a prime product, and getting 40+% chance of guessing correctly, isn't too bad I think for a total amateur.
Far cry from a couple years ago claiming I broke prime factorization. People still haven't forgiven me for that, lol.6 
A funny story I just remember while my code is compiling :
Back in high school, in Math, we were taught how algorithm works, and we made some exercises with practical examples.
I didn't know anything about it back then, so was curious. Was pretty fun, but one day, my teacher said that a IF is a loop. I said "no, this is a test" but she keeps saying that it was a loop, ignoring me (I dunno if she actually heard me) and no one actually noticed it as she repeated it several times (while I was saying that it's not). I just gave up trying to say it's wrong.8 
I just found something cool on accident.
Assuming you start the fibonacci sequence on 2, you can find any of the fibonacci numbers for a given index with a simple trick:
Let Phi = 1.618
Let your index n = n+1
Floor(phi**(n+1+0.328))+1 = the fibonacci number at index n in the sequence.
This probably breaks down past some point but its nifty.21 
Faster square roots?
Did you know if you multiply your
product by pi, and then use that as
the area of a circle while solving for
the radius, the result will be an
approximation of the square root
of your product.
Example:
let p (the product) = 492181
then √p = 701.5561274766261
492181*pi = 1,546,232~
(leaving off the fraction for
the sake of brevity)
area = 1,546,232
then the radius of the 'circle' would be 701.56
I wonder if anyone has stumbled on this before?13 
Sit down to do a math lab in Maple on university computers. Struggle for a while with shitty software. Click on a help link provided by Maple for an error I was getting.
BSOD outta nowhere.
Hadn't saved my work. And Maple was developed by the best university in Canada. I hope they all catch something rare and incurable and die.4 
Taken partly from an article I just read.
Russels paradox is a problem discovered by Bertrand Russel in 1901 when studying set theory.
He describes a set that contains all sets which do not contain themselves. The set of all pornstars does not contain itself for example, so it can be include in Russel's set, as well as many others.
But what about Russel's set itself? It doesnt contain itself so shouldnt it be included as well? But that would mean it DOES include itself which means it DOESNT belong to the set. And it would keep switching like this, monotonically, forever. Hence the paradox.
If it is monotonic then where we begin in the sequence doesnt matter. So lets do away with that bugbear.
Now if russels set IS the set of all sets that dont contain themselves then we get a paradox.
However if russels set merely *has* as a single subset, all sets that dont contain themselves, then shouldnt russel's set with one level of indirection, contain itself?15 
Just finished up some math homework
One of the problems involved finding the side lengths of a triangle
Spend a good 20 minutes fucking around with the law of sines and the law of cosines before I realized it was a right triangle, and so I could use the Pythagorean theorem
I'm an idiot3 
I'm currently volunteering as a student assistant at my school, and today I've gotten the same question 20x. What question do you ask: "Why doesn't ^ return the power of the 2 numbers?"
It turns out that last week they've had a Math class from a new teacher (no programming experience) who said that if you want the power of 2 numbers you have to use the ^ operator...
If you don't know how to program, please don't teach it!5 
Riddle:
Alice and bob want to communicate a secret message, lets say it is an integer.
We will call this msg0.
You are Chuck, an interloper trying to spy on them and decode the message.
For keys, alice chooses a random integer w, another for x, and another for y. she also calculates a fourth variable, x+y = z
Bob follows the same procedure.
Suppose the numbers are too large to bruteforce.
Their exchange looks like this.
At step 1, alice calculates the following:
msg1 = alice.z+alice.w+msg0
she sends this message over the internet to bob.
the value of msg1 is 20838
then for our second step of the process, bob calculates msg2 = bob.z+bob.w+msg1
msg2 equals 32521
he then sends msg2 to alice, and again, you intercept and observe.
at step three, alice recieves bob's message, and calculates the following: msg3 = msg2(alice.x+alice.w+msg0)
msg3 equals 19249. Alice sends this to bob.
bob calculates msg4 = msg3(bob.x+bob.w)
msg4 equals 11000.
he sends msg4 to alice
at this stage, alice calculates ms5.
msg5 = (msg4(alice.y)+msg0.
alice sends this to bob.
bob recieves this final message and calculates
the sixth and final message, which is the original hidden msg0 alice wanted to send:
msg6 = msg5bob.y
What is the secret message?
I'll give anyone who solves it without bruteforcing, a free cookie.18 
My Precalculus teacher has such overstrict rules on showing work.
1. On tests, degree signs must be shown in all work. This wouldn't be outrageous except that if the answer is right but a single degree sign is missing in the mandated shown work, the entire question is wrong even with a correct final answer because the "answer doesn't match up with the work".
2. We must show work in the exact form mandated from on class. If even a single step of work is missing or wrong on even one say homework problem, no credit even if the entire rest of the sheet is correct and complete.
3. Never applied to me, but if a homework problem cannot be solved by a student, they must write a sentence describing how far they got and what wasn't doable, or no credit on the entire homework. Did I mention it is checked daily and is 2 unweighted points with 50100 point tests?
4. On graphing calculator problems, one had to draw a rectangle representing the calculator screen, even for solving systems of equations without explicit drawing graphs as part of the problem, because otherwise, she had "no proof that a calculator was used". It isn't that hard to fake, and it was quite stupid.
5. Reference triangles were required even when completely unnecessary or the answers were assumed copied, even if a better method was shown in work.
And much, much more!4 
We'll build an mathematics6thgradercalculationgame in ITclass. ("MathTetris")
In Java.
I hate Java.9 
Does anyone else think discrete math is super satisfying? I love it so much more than algebra or Calc10

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.13 
Weeeell…
I have been in a team where every week they had this long and complex task of refactoring everything and changing lots of assets (~2 days of work every 2 weeks) cause the senior tards refused to use a script for it. Told them to use the goddamn backend or a script… the answer? “But that would take at least two days of work! Maybe even three! (As a one time job)” Math you ducking ducks! The second time you use it you are in a time profit!2 
For starters this is my first post, found devrant the other day you're all hilarious.
I hate math, I hate proofs. I'm in a class "Analysis of Algorithms" and I have understood and do understand the importance of optimizing algorithms and data structures and I understand the algorithms and data structures themselves. That being said, I'm fucking sick of math and proofs and all this bullshit that is probably pretty important but ugggghh, I guess I just have to push through, but writing this out helped.14 
Chances are configurable in the project. Custemer didn't understand why something ALWAYS happened when he set it to 100%

yeah..
customer: I have a problem.
Smart Cell: here's a math problem, just divide it 3 times by 10243 
Working with surds recently, and found some cool new identities that I don't think were known before now.
if n = x*y, and z = n.sqrt(), assuming n is known but x and y are not..
q = (surd(n, (1/(1/((n+z)1))))*(n**2))
r = (surd(n, (surd(n, x)surd(n, y)))*surd(n, n))
s = abs(surd(abs((surd(n, q)q)), n)/(surd(n, q)q))
t = (abs(surd(abs((surd(n, q)q)), n)/(surd(n, q)q))  abs(surd(n, abs(surd(n, q)+r)))+1)
(surd(n, (1/(1/((n+z)1))))*(n**2)) ~=
(surd(n, (surd(n, x)surd(n, y)))*surd(n, n))
for every n I checked.
likewise.
s/t == r.sqrt() / q.sqrt()
and
(surd(n, q)  surd(s, q)) ==
(surd(n, t)  surd(s, t))
Even without knowing x, y, r, or t.
Not sure if its useful, but its cool.
surd() is just..
surd(j, k ) = return (j+k.sqrt())*(jk.sqrt())
and d() is just the python decimal module for ease of use.13 
I think I did it. I did the thing I set out to do.
let p = a semiprime of simple factors ab.
let f equal the product of b and i=2...a inclusive, where i is all natural numbers from 2 to a.
let s equal some set of prime factors that are bsmooth up to and including some factor n, with no gaps in the set.
m is a the largest primorial such that f%m == 0, where
the factors of s form the base of a series of powers as part of a product x
1. where (x*p) = f
2. and (x*p)%f == a
if statement 2 is untrue, there still exists an algorithm that
3. trivially derives the exponents of s for f, where the sum of those exponents are less than a.
4. trivially generates f from p without knowing a and b.
For those who have followed what I've been trying to do for so long, and understand the math,
then you know this appears to be it.
I'm just writing and finishing the scripts for it now.
Thank god. It's just in time. Maybe we can prevent the nuclear apocalypse with the crash this will cause if it works.2 
I love technology. I love programming and developing software. I love selflearning new things.
But I REALLY REALLY REALLY hate Math. And suck at it too.
I want to study compsci at the university but I'm scared of the math.
Any tips?13 
Question  is this meaningful or is this retarded?
if
2*3 = 6
2*2 = 4
2*1 = 2
2*0 = 0
2*1 = 2
then why doesnt this work?
6/3 = 2
6/2 = 3
6/1 = 6
6/0 = 0
6/1 = 6
if n/0 is forbidden and 1/n returns the inverse of n, why shouldn't zero be its own inverse?
If we're talking "0" as in an infinitely precise definition of zero, then 1/n (where n is arbitrarily close to 0), then the result is an arbitrarily large answer, close to infinite, because any floating point number beneath zero (like an infinitely precise approximation of zero) when inverted, produces a number equal to or greater than 1.
If the multiplicative identity, 1, covers the entire set of integers, then why shouldn't division by zero be the inverse of the multiplicative identity, excluding the entire set? It ONLY returns 0, while anything n*1 ONLY returns n.
This puts even the multiplicative identity in the set covered by its inverse.
Ergo, division by zero produces either 0 or infinity. When theres an infinity in an formula, it sometimes indicates theres been
some misunderstanding or the system isn't fully understood. The simpler approach here would be to say therefore the answer is
not infinity, but zero. Now 'simpler' doesn't always mean "correct", only more elegant.
But if we represent the result of a division as BOTH an integer and mantissa
component, e.x
1.234567 or 0.1234567,
i.e. a float, we can say the integer component is the quotient, and the mantissa
is the remainder.
Logically it makes sense then that division by zero is equivalent to taking the numerator, and leaving it "undistributed".
I.e. shunting it to the remainder, and leaving the quotient as zero.
If we treat this as equivalent of an inversion, we can effectively represent the quotient from denominators of n/0 as 1/n
Meaning even 1/0 has a representation, it just happens to be 0.000...
Therefore
(n * (n/0)) = 1
the multiplicative identity
because
(n* (n/0)) == (n * ( 1/n ))
People who math. Is this a yea or nay in your book?25 
A couple times a week my girlfriend tells me that she leaves work. She travels with a motorised vehicle for about 45 minutes. I am responsible of cooking food on those days. The food preparation takes around 7 minutes of cutting vegetables and the cooking takes around 20 minutes. the current time of reading the message is 17:17. She had send the message at 17:08. At what time should I start making food in order to be finished at the time she gets home?
I start to relate more and more to school math questions...
Maybe I should make an app for this or website to calculate automatically.5 
More masturbation with numbers.
If you take some product p,
and do
√p**(1/p)
and it's factors
a**(1/p)
and
b**(1/p)
you might find something interesting.
Take for example
a=21977
b=43331
p=a*b=952285387
(√p)**(1/p) = 1.0000000108551363
a**(1/p) = 1.0000000104986928
b**(1/p) = 1.0000000112115799
More often then not, a, b, or both, will share one or two of the most significant digits in the mantissa, as the root of p.
It doesn't always work, but it seems to be true more often than you might expect.
This is probably obvious in hindsight but I still think it's cool.
In some instances if you then do, say
sqrt(log(p, 1.000000010)), it comes pretty close to the original factors, but thats really hit or miss.8 
So.. name one fucken case where your database is not a computer backed thing.
Just asking because.. why the fuck? I don't think your database server supports input of fucking math symbols? JUST USE HUMAN LANGUAGE, AS YOU HAVE TO DO ANYWAY!
It's stupid how everything needs to be expressed mathematically ffs. Not that it's hard to understand  it's just more complex than of a very simple wording.5 
Develop my first mobile app with a restful backend for consumer usage
Learn more about cloud architecture/computing
Finish learning calculus
Learn linear algebra, discrete math, statistics and probability
Maybe start ML this year depending on math progress and time2 
I think I've reached the point where I've been programming for so long that I have off by one errors doing normal math by hand. Nothing more humbling than getting beat out to a bunch of simple math problems to a grade schooler.

That moment when you just quit your successful paying job just to have more time to study and try to pass the fucking piece of trash math exam.
Fuck my asshole, fuck my life and fuck that motherfucking college degree. If I don't pass, I will eventually kill my self or quit college.
Jeez, I wonder what was in my head when I enrolled in college, oh wait.. Parents, society brainwashed me to think I need top tier education to be a successful computer programmer engineer.
Fuck you society, fuck my brain, fuck everything.9 
I see a lot of talk about complex numbers, and yet
for all they are worth, I have not once been
able to find an explaination on how to calculate
them by hand, namely the real component.
For example
(5)**0.5
(1.3691967456605067e16+2.23606797749979j)
2.23606 is obviously just the square root of 5, but where the hell did 1.369 come from?
Apparently no one fucking knows, and no site I've found gives a simple explanation for someone new to math in general.
"use a calculator", "hit a button",
How about no.9 
So I got to thinking about computer systems and how they are all based on binary. So the math we perform is obviously based upon a binary approach. Then I started wondering if there was value in exploring math using a different base. I know in math we can shift things to a different domain to do things more efficiently (like Laplace transforms to get to the frequency domain to do freq based calcs, or quaternions to do various orientation calcs). I thought maybe a base 3 logic might do some calcs better. I searched and found that indeed some ternary computing systems had been built. I then searched for libraries that might employ ternary math as an exploration exercise. I didn't find anything except academic articles (few at that).
This idea of changing the base in the math (and possibly the frame of reference) is interesting. It is like searching for treasure and not being sure it even exists.
https://en.wikipedia.org/wiki/...5 
Husband looking into online schools for CS. Anything data science related. He loves math (and is freaking good at it) and teaches himself R for fun.
I put 0 thought into my own schools (terrible, I know, but not likely to change any time soon). Any suggestions for good online data Science programs, with a math minor potentially?
It's for his bachelor's.6 
While I was exploring multiplication tables I stumbled on something cool.
Take any power of 2 on the multiplication chart.
Now look at the number in the bottom left adjacent box.
The difference of these two numbers will always be a Mersenne number.
Go ahead. Starting on the 2's column of a multiplication table, look in the bottom left of each power of 2 and get the difference.
22 = 0
43= 1
85 = 3
169=7
3217=15
etc.
While the online journal of integer sequences lists a lot of forumlas, I just wrote what came to mind (I'm sure its already known):
((2**i)(((2**i)/2)+1))
The interesting thing about this is it generates not only the Mersenne numbers, but if you run i *backwards* it generates *additional* numbers.
So its a superset of mersenne numbers.
at i = 0 we get 0.5
i=1 > 0.75
i=2 > 0.875
i=3 > 0.9375
i=4 > 0.96875
And while this sequence is *not* mersenne numbers, mersenne numbers *are* in this set.
Just a curious discovery is all.10 
I have two math final exams on the same day, and one is scheduled 30 minutes after the first one 🙁🙁
I fucking hate math, and this shit sure isn't helping me.7 
I should have studied for my math exam, but now I can program a terminal calculator in FORTRAN77
//masterofprocrastonation 
Officially faster bruteforcing:
https://pastebin.com/uBFwkwTj
Provided toy values for others to try. Haven't tested if it works with cryptographic secure prime pairs (gcf(p, q) == 1)
It's a 50% reduction in time to bruteforce a semiprime. But I also have some inroads to a/30.
It's not "broke prime factorization for good!" levels of fast, but its still pretty nifty.
Could use decimal support with higher precision so I don't cause massive overflows on larger numbers, but this is just a demonstration after all.13 
Today I finally experienced the power of something I learned in university: propositional and predicate logic.
Many developers I know think that such education is useless. Well, today I have proven that it is very useful. On a day to day basis, working on banking software, complexity in purely logic is very low. However, we have a screen that must show or hide elements based on some input values and conditions associated with certain elements. How hard can that be, right? Well, there are many variables to take into account and as such it's absolutely not trivial.
This screen didn't work properly and maintaining the code is hard as there is a lot of logic to show/hide, enable/disable things and so on. After quite some time and attempts by fellow developers, I decided to refactor the whole thing. I'm responsible for the quality of the software and it was quite degrading, so I had to do something.
In order to get things working properly, I defined collections of constants (ui elements) and predicates. Then, I defined for which element what predicates must be true, in order to hide/show, disable/enable etc. I then translated these predicates into code. And guess what? It works! Of course it works. It's logic. But I'm very pleased I finally could actually use some of all the math I studied!5 
So while exploring some new ideas, I decided to figure out if I could use variables in the known set to determine the bounds of variables in the unknown set.
The variables in question are algebraic identities derived from the semiprimes, so you already know where this is going.
The existing known set is 1194 identities.
And there are, if I recall, roughly two dozen unknowns.
Many knowns have the unknowns as their factors. The d4 product set for example is composed of variables d4a, d4u, d4z, d4z9, d4z4, d4alpha, d4theta, d4omega, etc.
The component variables themselves are unknown, just their products are known. Anyway.
What I've found interesting is if you know the minimum of some of these subsets, for example d4z is smallest out of the d4's for some semiprimes, then you know the upperbound of both the component variables d4 and z.
Unless of course either of them is < 1.
So the order of these variables, based on value, changes depending on the properties of the semiprime, which I won't get into. Most of the time the order change is minor, but for some variables they can vary a lot between semiprimes, rapidly shifting their rank in the known set. This makes it hard to do anything with them.
And what I found myself asking, over and over again, was if there was a way to lock them down? Think of it like a giant switch board, where flipping one switch lights up N number of others, apparently at random. But flipping some other switch completely alters how that first switch works and what lights it seemingly interacts with. And you have a board of them thats 1194^2 in total. So what do you do?
I'd had a similar notion a while back, where I would measure relative value in the known set, among a bunch of variables, assign a letter if the conditions were present, and generate a string, called a "haplotype."
It was hap hazard and I wrote a lot of code to do filtering, sorting, and set manipulation to find sets of elements in common, unique elements, etc. But the 'type' strings, a jumble of random letters, were only useful say, forty percent of the time. For example if a semiprime had a particular type starting with a certain series of letters, 40% of the time a certain known variable was guaranteed to be above a certain variable from the unknown set...40%~ of the time.
It was a lost cause it seemed.
But I returned to the idea recently and revamped the entire notion.
Instead what I would approach it from a more complete angle.
I'd take two known variables J and K, one would be called the indicator, and the other would be the 'target'.
Two other variables would be the 'component' variables (an element taken from the unknown set), and the constraint variable (could be from either the known or unknown set).
The idea was that relationships between the KNOWN variables (an indicator and a target variable) could be used to indicate the rank relationship between the unknown component variable and the constraint variable.
You'd think this wouldn't work either, but my intuition was there were so many seemingly 'random' rank changes of variables in the known set for any two semiprimes, that 1. no two semiprimes ever shared the same order for every variable, and 2. the order of the known variables had to be leaking information about the relationships of the unknown variables.
It turns out my intuition was correct.
Imagine you are picking a lock, and by knowing the order and position of the first two pins, you are able to deduce the relative position of two pins further back that you can't reach because of the locks security features. It doesn't let you unlock the lock directly, but by knowing this, if you can get past the lock's security features, you have a chance of using information about the third pin to get a better, if incomplete, understanding about the boundary position of the last pin.
I would initiate a big scoring list, one for each known element or identity. And then I would check it in tandem like so:
if component > constraint and indicator > target:
indicator[j]+= 1
This is a simplication, but the idea was to score ALL such combination of relationship, whether the indicator was greater than the target at the same time a component was greater than a constraint, or the opposite.
This worked out to four if checks and four separate score lists.
And by subtracting one scorelist from another, I could check for variables that were a bad fit: they'd have equal probability of scoring for example, where they were greater than the target one time, and then lesser than it for another semiprime.
So for any given relationship, greater or lesser between any unknown variable and constraint variable, I could find any indicator variable and target variable whose relationship strongly correlated to the unknown's.18 
If you want a really obtuse method for inverting numbers in python, here you go:
z0 = Decimal('78.56341431805592768684300246940000494686645802145994376216014333')
z1 = Decimal('1766612.615660056866253324637112675800498420645531491441947721134')
z2 = Decimal('1766891.018224248707391295083927186110075710886547799081463050088')
z3 = Decimal('15658548.51274600264911287951105338985790517559073271799766738859')
z4 = Decimal('1230189034.426242656418217548674280136397763003160663651728899428')
z5 = Decimal('1.000157591178577552497828947885508869785153918881552213564806501')
((((z0/(z1/(z2/(n)))))*(z3))/z4)/z5
From what I can see, it works for any value of n.
I have no clue why it works.
Also have a function to generate the z values for any n input.
Shitpost studios.
Bringing you QUALITY math posts since 2019!
"we shitpost because we care."21 
Student: I f*cking hate this calculus I am not even good in math.
Professor: Then why did you choose Computer Engineering it needs a lot of math.
Student: Because I love computer.
Professor: 'FacePalm'3 
can we just get rid of floating points? or at least make it quite clear that they are almost certainly not to be used.
yes, they have some interesting properties that make them good for special tasks like raytracing and very special forms of math. but for most stuff, storing as much smaller increments and dividing at the end (ie. don't store money as 23.45. store as 2,345. the math is the same. implement display logic when showing it.) works for almost all tasks.
floating point math is broken! and most people who really, truely actually need it can explain why, which bits do what, and how to avoid rounding errors or why they are not significant to their task.
or better yet can we design a standard complex number system to handle repeating divisions and then it won't be an issue?
footnote: (I may not be perfectly accurate here. please correct if you know more)
much like 1/3 (0.3333333...) in base 10 repeats forever, that happens with 0.1 in base 2 because of how floats store things.
this, among other reasons, is why 0.1+0.2 returns 0.300000046 
What paradoxes taught me.
Perhaps each time a paradox is encountered in mathematics, there is a useful distinction or mathematical tool hiding in plain sight, one that hasn't be discovered or utilized. For cursory evidence I give you: division by zero, the speed of an arrow at any point in flight, and calculus.
Maybe this isn't true for some paradoxes, or even most, but as time goes on I suspect people will discover it is more true than they might have thought.
Undefined behavior and results aren't nonsense: They look to me like golden seams to be explored for possible utility when approached from uncommon angles with uncommon problems.6 
If I have four unknown variables, x, y, j, and k, but know the values of x*j, y/k, and k/j, and x*j == y/k
How do I go about getting the values of the individual unknown variables?10 
When we subtract some number m from another number n, we are essentially creating a relationship between n and m such that whatever the difference is, can be treated as a 'local identity' (relative value of '1') for n, and the base then becomes '(base n/(nm))%1' (the floating point component).
for example, take any number, say 512
697/(697512)
3.7675675675675677
here, 697 is a partial multiple of our new value of '1' whose actual value is the difference (697512) 185 in base 10. proper multiples on this example number line, based on natural numbers, would be
185*1,
185*2
185*3, etc
The translation factor between these number lines becomes
0.7675675675675677
multiplying any base 10 number by this, puts it on the 1:185 integer line.
Once on a number line other than 1:10, you must multiply by the multiplicative identity of the new number line (185 in the case of 1:185), to get integers on the 1:10 integer line back out.
185*0.7675675675675677 for example gives us
185*0.7675675675675677
142.000000000000
This value, pulled from our example, would be 'zero' on the line.
185 becomes the 'multiplicative' identity of the 1:185 line. And 142 becomes the additive identity.
Incidentally the proof of this is trivial to see just by example. if 185 is the multiplicative identity of 697512, and and 142 is the additive identity of number line 1:185
then any number '1', or k=some integer, (185*(k+0.7675675675675677))%185
should equal 142.
because on the 1:10 number line, any number n%1 == 0
We can start to think of the difference of any two integers n, as the multiplicative identity of a new number line, and the floating point component of quotient of any number n to the difference of any number nm, as the additive identity.
let n =697
let m = 185
nm == '1' (for the 1:185 line)
(nm) * ((n/(nm))%1) == '0'
As we can see just like on the integer number line, n%1 == 0
or in the case of 1:185, it equals 142, our additive identity.
And now, the purpose of this long convoluted post: all so I could bait people into reading a rant on division by zero.30 
I already forgot what are the different sorting algorithms I learned last week. I already forgot sin, cos, tan, log, and some Math concepts in school. How not to forget these things easily? I could recall them once I see a sample and a brief explanation.4

When I was in seventh grade, I learned to solve quadratic equations and how to convert from standard form to vertex form
Today, when I had to convert a quadratic equation, I completely blanked on how to do it
I can’t remember how to do math seventh graders know
Fml3 
I'm fairly new (less than a year) to programming and I'm just wondering what everyone's thoughts are about this.
Is taking college math courses necessary to be a good programmer?
I am learning online and I'm worried I won't be a great programmer without all the math. The last course I took was Trig :/
Also add any suggestions you have. Thanks all!27 
At math lessons I was like: "WTF is this shit, I don´t need that." Well I figured out that coding is not "copy&paste" from SO. :)

https://en.wikipedia.org/wiki/...
Is an interesting read.
May have applications of measuring the randomness of RNGs, as deviation from Viswanath's constant3 
heres something interesting:
The golden ratio is 1.618...
If you're not familiar with it, doing 1/goldenratio
the result is 0.618...
It gives you back the float component exactly.
Discovered that it is actually part of a series.
First of all:
2(((5sqrt(5))/2)1) =
1.618033988749895 > thats our golden ratio
In other words:
(2%gold) =
0.381966011250106
While:
((5sqrt(5))/2) =
1.381966011250105
Ok, now we're getting somewhere. We can turn these into variables
First of all, lets see if we can get the golden ratio back out:
2(((5sqrt(5))/2)1) = 1.618033988749895
Okay good.
The formula looks something like
j(((isqrt(i))/2)1)
Where j = (i*2)+1
That means we can easily figure out what j we need from our i value. (i1)/2 = j
We run it back far enough we get
1(((3sqrt(3))/2)1) =
1.3660254037844386
Thats the golden ratios little brother. Doesn't look anything like it, but it is part of the series.
And I found a boat load of research documents scattered *all* over the net, where this number and others in the series inexplicably crop up in power series, in chemistry, and elsewhere. Just looks like random floats if you don't know better.
We can actually go lower in the series:
0.5(((2sqrt(2))/2)1)
1.2071067811865475
At the lowest positive value for j, we get
0(((1sqrt(1))/2)1) = 1
It's kinda elegant.
I even wrote a little script to do the conversions:
def gr(k):
....i = k
....j = (i1)/2
....return j(((isqrt(abs(i)))/2)1)
The dots are so devrant doesn't break pythons formatting.3 
Colleague: The user said this [Total line] is not the average she expected.
Me: Okay? But she knows that averages are weighted?
Colleague: I'm gonna call her.
... 30 minutes fast forward
Colleague: Okay she wants an average, but she wants us to divide it by something else.
Me: Okay? But she knows an average is the sum of one thing divided by the sum of another thing and not just anything?
Colleague: Yeah, she said she wants it to be kinda this in relation to that.
Me: Okay, so rather some percentage value?
Colleague: To be honest, she just wanted to reproduce this old Excel formula.
God has left this planet ... and I admire my colleague for not completely freaking out in the face of the user.3 
When you're doing a math problem at school and you can't solve problems with loops and if statements2

!rant
I posted a rant a few days ago, saying Math sucks and I fucking hate it.
Don't you love it though, when everything falls into place nicely when it's really just mathematical laws. It's beautiful3 
I've been away a while, mostly working 6070 hour weeks.
Found a managers job and the illusion of lowlevel stability.
Also been exploring elliptic curve cryptography and other fun stuff, like this fun equation...
i = log(n, 2**0.5)
base = (((int((n/(n*(1(n/((((abs(int(n+(n/(1/((n/(ni))+(i+1)))))+i)(i*2))/1))/1/i)))))*i)i)+i))
...as it relates to A143975 a(n) = floor(n*(n+3)/3)
Most semiprimes n=pq, where p<q, appear to have values k in the sequence, where k is such that n+m mod k equals either pq or a multiple thereof.
Tested successfully up to 49 bits and counting. Mostly haven't gone further because of work.
Theres a little more math involved, and I've (probably incorrectly) explained the last bit but the gist is the factorization doesn't turn up anything, *however* trial lookups on the sequence and then finding a related mod yields k instead, which can be used to trivially find p and q.
It has some relations to calculating on an elliptic curve but thats mostly over my head, and would probably bore people to sleep.2 
Yesterday was my first day at Uni and it was amazing. We did just math like for 7 hours and today too. Actually we're gonna be doing it the whole week even on saturday. Finally I can study what I want 💪.
Just wanted to share my excitement with my fellow devs 😉.5 
We were in math class at computers because we should test our math skills. Had some HTML skills at that point So on the score page changed my score to the best score. The first time I experienced the chrome developer tools.

Was driving home last night when I noticed that my car was slowly drifting side to side. It felt weird like when a tire is low/flat. So I gradually slowed down from 50mph to 40mph. Note, I did this carefully and slowly. My antilock brakes kicked in. Like holy hell how slick does a road have to be for a small deceleration like that to kick in antilocks?
So it made me think of a math question:
If a typically sized sedan (weighing 2 tons) decelerates from 50mph to 40mph and the antilock brakes kick in, what it the frictional coefficient of the surface of the road? Also assuming typical nonbald all season tires.
Multiple choice:
a) slick
b) really slick
c) REALLY FUCKING SLICK!7 
After a lot of work, the new factorization algorithm has a search space thats the factorial of (log(log(n))**2) from what it looks like.
But thats outerloop type stuff. Subgraph search (inner loop) doesn't appear to need to do any factor testing above about 97, so its all trivial factors for sequence analysis, but I haven't explored the parameter space for improvements.
It converts finding the factors of a semiprime into a sequence search on a modulus related to
OIS sequence A143975 a(n) = floor(n*(n+3)/3)
and returns a number m such that n=pq, m%p == 0(p*i), but m%q != 0(q*k)
where i and k are respective multiples of p and q.
This is similar in principal to earlier work where I discovered that if i = p/2, where n=p*q then
r = (abs(((((n)(9**i)9)+1))((((9**i)(n)9)2)))n+1+1)
yielding a new number r that shared p as a factor with n, but is coprime with n for q, meaning you now had a third number that you could use, sharing only one nontrivial factor with n, that you could use to triangulate or suss out the factors of n.
The problem with that variation on modular exponentiation, as @hitko discovered,
was that if q was greater than about 3^p, the abs in the formula messes the whole thing up. He wrote an improvement but I didn't undertsand his code enough to use it at the time. The other thing was that you had to know p/2 beforehand to find r and I never did find a way to get at r without p/2
This doesn't have that problem, though I won't play stupid and pretend not to know that a search space of (log(log(n))**2)! isn't an enormous improvement over state of the art,
unless I'm misunderstanding.
I haven't posted the full details here, or sequence generation code, but when I'm more confident in what my eyes are seeing, and I've tested thoroughly to understand what I'm looking at, I'll post some code.
hitko's post I mentioned earlier is in this thread here:
https://devrant.com/rants/5632235/...2 
Everytime I consult with senior devs on how to transition from my sysadmin job and get my first dev job they always tell me to get a CS degree.
Look. I will get that fucking degree eventually. But I want to build up dev skills and learn from a company before killing myself over math crap for 3 years. But it's like a vicious cycle. Every junior position I apply to rejects me because I have no degree.
I'm fucking frustrated and depressed.
What should I do? I want to break from the IT meme and get a dev job.
In the meantime I'm doing small projects and freelancing in my very little free time. But I feel I'll never truly be a developer until I work as one professionally.4 
Do you have to be a math genius to program?
I myself hate math but have been programming for a hobby in about 3 years now.
I keep hearing that you have to know a lot of math to program even though i usually only use basic math when i do.9 
After learning a bit about alife I was able to write
another one. It took some false starts
to understand the problem, but afterward I was able to refactor the problem into a sort of alife that measured and carefully tweaked various variables in the simulator, as the algorithm
explored the paramater space. After a few hours of letting the thing run, it successfully returned a remainder of zero on 41.4% of semiprimes tested.
This is the bad boy right here:
tracks[14]
[15, 2731, 52, 144, 41.4]
As they say, "he ain't there yet, but he got the spirit."
A 'track' here is just a collection of critical values and a fitness score that was found given a few million runs. These variables are used as input to a factoring algorithm, attempting to factor
any number you give it. These parameters tune or configure the algorithm to try slightly different things. After some trial runs, the results are stored in the last entry in the list, and the whole process is repeated with slightly different numbers, ones that have been modified
and mutated so we can explore the space of possible parameters.
Naturally this is a bit of a hodgepodge, but the critical thing is that for each configuration of numbers representing a track (and its results), I chose the lowest fitness of three runs.
Meaning hypothetically theres room for improvement with a tweak of the core algorithm, or even modifications or mutations to the
track variables. I have no clue if this scales up to very large semiprime products, so that would be one of the next steps to test.
Fitness also doesn't account for return speed. Some of these may have a lower overall fitness, but might in fact have a lower basis
(the value of 'i' that needs to be found in order for the algorithm to return rem%a == 0) for correctly factoring a semiprime.
The key thing here is that because all the entries generated here are dependent on in an outer loop that specifies [i] must never be greater than a/4 (for whatever the lowest factor generated in this run is), we can potentially push down the value of i further with some modification.
The entire exercise took 2.1735 billion iterations (34 hours, wasn't paying attention) to find this particular configuration of variables for the current algorithm, but as before, I suspect I can probably push the fitness value (percentage of semiprimes covered) higher, either with a few
additional parameters, or a modification of the algorithm itself (with a necessary rerun to find another track of equivalent or greater fitness).
I'm starting to bump up to the limit of my resources, I keep hitting the ceiling in my RADstyle write>test>repeat development loop.
I'm primarily using the limited number of identities I know, my gut intuition, combine with looking at the numbers themselves, to deduce relationships as I improve these and other algorithms, instead of relying strictly on memorizing identities like most mathematicians do.
I'm thinking if I want to keep that rapid write>eval loop I'm gonna have to upgrade, or go to a server environment to keep things snappy.
I did find that "jiggling" the parameters after each trial helped to explore the parameter
space better, so I wrote some methods to do just that. But what I wouldn't mind doing
is taking this a bit of a step further, and writing some code to optimize the variables
of the jiggle method itself, by automating the observation of realtime track fitness,
and discarding those changes that lead to the system tending to find tracks with lower fitness.
I'd also like to break up the entire regime into a training vs test set, but for now
the results are pretty promising.
I knew if I kept researching I'd likely find extensions like this. Of course tested on
billions of semiprimes, instead of simply millions, or tested on very large semiprimes, the
effect might disappear, though the more i've tested, and the larger the numbers I've given it,
the more the effect has become prevalent.
Hitko suggested in the earlier thread, based on a simplification, that the original algorithm
was a tautology, but something told me for a change that I got one correct. Without that initial challenge I might have chalked this up to another false start instead of pushing through and making further breakthroughs.
I'd also like to thank all those who followed along, helped, or cheered on the madness:
In no particular order ,demolishun, scor, root, iiii, karlisk, netikras, fastnop, hazarth, chonkyquiche, Midnightshcode, nanobot, c0d4, jilano, kescherrant, electrineer, nomad,
vintprox, sariel, lensflare, jeeper.
The original write up for the ideas behind the concept can be found at:
https://devrant.com/rants/7650612/...
If I left your name out, you better speak up, theres only so many invitations to the orgy.
Firecode already says we're past max capacity!5 
Having a degree in math helpes immensely with programming. Abstract reasoning, calculation simplification, sussinct data representation, nice things to have.

More math (because it's 5am and currently the apocalypse so why not).
e  log(log(e, 1.444667861009766**1.444667861009766), log(e, e**1.444667861009766)) = 1
I've been studying so long if I happen to glance at a pocket calculator I might jizz in my pants.
Thinking BigBrain thoughts right now bois! (tm).
Oh shit. Cant stop. I think I opened a portal bros! and am being sucked in. ITS A BLACK HOLE!18 
So I promised a post after work last night, discussing the new factorization technique.
As before, I use a method called decon() that takes any number, like 697 for example, and first breaks it down into the respective digits and magnitudes.
697 becomes > 600, 90, and 7.
It then factors *those* to give a decomposition matrix that looks something like the following when printed out:
offset: 3, exp: [[Decimal('2'), Decimal('3')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('2')]]
offset: 2, exp: [[Decimal('2'), Decimal('1')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: [[Decimal('7'), Decimal('1')]]
Each entry is a pair of numbers representing a prime base and an exponent.
Now the idea was that, in theory, at each magnitude of a product, we could actually search through the *range* of the product of these exponents.
So for offset three (600) here, we're looking at
2^3 * 3 ^ 1 * 5 ^ 2.
But actually we're searching
2^3 * 3 ^ 1 * 5 ^ 2.
2^3 * 3 ^ 1 * 5 ^ 1
2^3 * 3 ^ 1 * 5 ^ 0
2^3 * 3 ^ 0 * 5 ^ 2.
2^3 * 3 ^ 1 * 5 ^ 1
etc..
On the basis that whatever it generates may be the digits of another magnitude in one of our target product's factors.
And the first optimization or filter we can apply is to notice that assuming our factors pq=n,
and where p <= q, it will always be more efficient to search for the digits of p (because its under n^0.5 or the square root), than the larger factor q.
So by implication we can filter out any product of this exponent search that is greater than the square root of n.
Writing this code was a bit of a headache because I had to deal with potentially very large lists of bases and exponents, so I couldn't just use loops within loops.
Instead I resorted to writing a three state state machine that 'counted down' across these exponents, and it just works.
And now, in practice this doesn't immediately give us anything useful. And I had hoped this would at least give us *upperbounds* to start our search from, for any particular digit of a product's factors at a given magnitude. So the 12 digit (or pick a magnitude out of a hat) of an example product might give us an upperbound on the 2's exponent for that same digit in our lowest factor q of n.
It didn't work out that way. Sometimes there would be 'inversions', where the exponent of a factor on a magnitude of n, would be *lower* than the exponent of that factor on the same digit of q.
But when I started tearing into examples and generating test data I started to see certain patterns emerge, and immediately I found a way to not just pin down these inversions, but get *tight* bounds on the 2's exponents in the corresponding digit for our product's factor itself. It was like the complications I initially saw actually became a means to *tighten* the bounds.
For example, for one particular semiprime n=pq, this was some of the data:
n  offset: 6, exp: [[Decimal('2'), Decimal('5')], [Decimal('5'), Decimal('5')]]
q  offset: 6, exp: [[Decimal('2'), Decimal('6')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('5')]]
It's almost like the base 3 exponent in [n:7] gives away the presence of 3^1 in [q:6], even
though theres no subsequent presence of 3^n in [n:6] itself.
And I found this rule held each time I tested it.
Other rules, not so much, and other rules still would fail in the presence of yet other rules, almost like a giant switchboard.
I immediately realized the implications: rules had precedence, acted predictable when in isolated instances, and changed in specific instances in combination with other rules.
This was ripe for a decision tree generated through random search.
Another product n=pq, with mroe data
q(4)
offset: 4, exp: [[Decimal('2'), Decimal('4')], [Decimal('5'), Decimal('3')]]
n(4)
offset: 4, exp: [[Decimal('2'), Decimal('3')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('3')]]
Suggesting that a nontrivial base 3 exponent (**2 rather than **1) suggests the exponent on the 2 in the relevant
digit of [n], is one less than the same base 2 digital exponent at the same digit on [q]
And so it was clear from the get go that this approach held promise.
From there I discovered a bunch more rules and made some observations.
The bulk of the patterns, regardless of how large the product grows, should be present in the smaller bases (some bound of primes, say the first dozen), because the bulk of exponents for the factorization of any magnitude of a number, overwhelming lean heavily in the lower prime bases.
It was if the entire vulnerability was hiding in plain sight for four+ years, and we'd been approaching factorization all wrong from the beginning, by trying to factor a number, and all its digits at all its magnitudes, all at once, when like addition or multiplication, factorization could be done piecemeal if we knew the patterns to look for.7 
For middle and high school:
1. Let people teach who actually know what they are doing
2. Learning by doing is in my opinion the only good way to "teach" someone how to code.
(And well theory is just like math. So teach it like math.)5 
I may have accidentally found a legit factorization method that converts factoring to a combinatorics problem over a graph, with a time complexity that is the factorial of the logarithm of the semi prime being factored.
I don't know if this is supposed to be good or not, and I don't want to post it prematurely like I almost always do. Not at least until I study its properties better, but it's still a pretty interesting find I think.11 
http://ipkitten.blogspot.com/2018/...
HOW THE FUCK IS THIS LEGAL?! This isn't even their fucking research! So much of this was either done decades before they existed, or done by others. In the first place, since when can you patent fucking math?! Sure we haven't seen the full patents but they should focus on specific implementations if anything and the titles clearly do not reflect that.
So much for "don't be evil", fuck Google 
Math is like a language syntax. You understand the meaning of needed symbols and keywords, then you can write it the way you want.
Physics is like a framework. You have to understand how problems can be solved using patterns someone else thinks is the best way.
This is what I think when I should be reading for the big test of physics and math for upper secondary school.2 
any mathematician turned devs here?
I think developers with a formal mathematical education should be the ones actually developing softwares. Ordinary developers are just good cooks who know to prepare these recipes by knowing to mix and manage the Ingredients through their experience, developing software using various libraries and frameworks, I don't understand what innovation we devs do in it, makes me feel less passionate about my work sometimes.
(I embrace the fact that being a developer requires an arstisic craftsmanship to do it properly)9 
So I have a problem and I was hoping for some insight.
I figured out how to get
(surd(n, x)surd(n, y))
without knowing x or y, (only n), through a convergent series of approximate identities.
n is the product of x and y, where x<y
My only issue is I don't know where to go from here. I've basically hit the limit of my insight into the problem.
surd() here is just a function that returns the results of two arguments, a, b, such that (a^2)b.
Both are guaranteed to be positive integers, greater than 1.
But, having come this far, with a couple pages of intermediate identities, I'm at a loss.4 
I have an internship at some research company. My point is making face recognition apps with prog lang I know. This place is awesome. Well, compsci it's not my background, but I met many people. And they are great at math ....
.....
... Like they do 29 grayscale images as a vector for PCA algorithm with size 64x64 pixel and COUNT A COVARIANCE MATRIXES WITHOUT TOUCHING ANY CALCULATOR OR PEN AND PAPER AND GET THE RIGHT NUMBER!
Man, this is insane. I don't even know 64x64. I love compsci1 
Mathematics feels like a giant old undocumented codebase in that, yes you could read the comments of each function, you would rather have a nice complete, well formatted docs page that in human terms explains how things work together, why they are here and where they came from.13

Writing ! instead of ~ to make a true logic statement negative in Math exam.
Like: ~p=>q —–> !p=>q1 
I don't like vector math for gamedev. It's not that it's hard. Vector math isn't hard until operations become O(n log n). It's that it's unintuitive, slow to write, and when I finally come to a solution after arduous number crunching, it always looks obvious, boring and kind of ugly. I don't think I could ever write a piece of vector math that I could be proud of.2

While the topic is a bit divisive, the statistical technique highlighted in this post is really cool:
https://wattsupwiththat.com/2022/...2 
Math question time!
Okay so I had this idea and I'm looking for anyone who has a better grasp of math than me.
What if instead of searching for prime factors we searched for a number above p?
One with a certain special property. BEAR WITH ME. I know I make these posts a lot and I'm a bit of a shitposter, but I'm being genuine here.
Take this cherry picked number, 697 for example.
It's factors are 17, and 41. It's trivial but just for demonstration.
If we represented it's factors as a bit string, where each bit represents the index that factor occurs at in a list of primes, it looks like this
1000001000000
When converted back to an integer that number becomes 4160, which we will call f.
And if we do 4160/(2**n) until the result returns
a fractional component, then N in this case will be 7.
And 7 is the index of our lowest factor 17 (lets call it A, and our highest factor we'll call B) in our primes list.
So the problem is changed from finding a factorization of p, to finding an algorithm that allows you to convert p into f. Once you have f it's a matter of converting it to binary, looking up the indexes of all bits set to 1, and finding the values of those indexes in the list of primes.
I'm working on doing that and if anyone has any insights I'm all ears.9 
Oh god, here comes another math post! I can feel it coming on, like werewolfism during the full moon.
I'm only passingly familiar with logarithms, so this, like everything I've stumbled on, has probably already been discovered, but
n/(1/((n^(1/n))1))
Is a pretty good approximation (within a couple percentage points, or three or more digits) of the natural logarithm for all the numbers I've checked it on.
For example if
n = 690841693
ln(n) = 20.35342125707679
while our estimate using the above formula comes out to:
n/(1/((n**(1/n))1)) = 20.353421612948146
Am I missing something obvious here, and if so, what?
Am I doing the idiot savant thing again, or am I just being an idiot again?10 
Applied Discrete Math is fucking hard. Logic and proofs are freaking hard. Even Multivariable calculus is piece of cake. Give me Calculus, Linear Algebra and I can get a high grade.
How do you even start to wrote proofs?
I’m in Chapter 2 and struggling. Imagine the later chapters.6 
Either a math/physics related job(teacher, scientist or something like that) since I love tgem and have a knack for it, or a military career which I wanted but they didn't let me stay :C
So dev it is 
This is my first year in college specialty computer science, the first year we only study math and physics and reading ur guys rants and questions i seriously understand only 3 words hahahahah but it sounds sooo interesting!!!!!!
Side questions
Why are they concentrating on math so much in college ???8 
Probably pure coincidence but if you look at the deconstruction of the dedekinds like so:
>>> decon(6)
offset: 1, exp: [[Decimal('2'), Decimal('1')], [Decimal('3'), Decimal('1')]]
>>> decon(20)
offset: 2, exp: [[Decimal('2'), Decimal('2')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: []
>>> decon(168)
offset: 3, exp: [[Decimal('2'), Decimal('2')], [Decimal('5'), Decimal('2')]]
offset: 2, exp: [[Decimal('2'), Decimal('2')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: [[Decimal('2'), Decimal('3')]]
>>> decon(7581)
offset: 4, exp: [[Decimal('2'), Decimal('3')], [Decimal('5'), Decimal('3')], [Decimal('7'), Decimal('1')]]
offset: 3, exp: [[Decimal('2'), Decimal('2')], [Decimal('5'), Decimal('3')]]
offset: 2, exp: [[Decimal('2'), Decimal('4')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: []
>>> decon(7828354)
offset: 7, exp: [[Decimal('2'), Decimal('6')], [Decimal('5'), Decimal('6')], [Decimal('7'), Decimal('1')]]
offset: 6, exp: [[Decimal('2'), Decimal('8')], [Decimal('5'), Decimal('5')]]
offset: 5, exp: [[Decimal('2'), Decimal('5')], [Decimal('5'), Decimal('4')]]
offset: 4, exp: [[Decimal('2'), Decimal('6')], [Decimal('5'), Decimal('3')]]
offset: 3, exp: [[Decimal('2'), Decimal('2')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('2')]]
offset: 2, exp: [[Decimal('2'), Decimal('1')], [Decimal('5'), Decimal('2')]]
offset: 1, exp: [[Decimal('2'), Decimal('2')]]
>>> decon(d('2414682040998'))
offset: 13, exp: [[Decimal('2'), Decimal('13')], [Decimal('5'), Decimal('12')]]
offset: 12, exp: [[Decimal('2'), Decimal('13')], [Decimal('5'), Decimal('11')]]
offset: 11, exp: [[Decimal('2'), Decimal('10')], [Decimal('5'), Decimal('10')]]
offset: 10, exp: [[Decimal('2'), Decimal('11')], [Decimal('5'), Decimal('9')]]
offset: 9, exp: [[Decimal('2'), Decimal('9')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('8')]]
offset: 8, exp: [[Decimal('2'), Decimal('10')], [Decimal('5'), Decimal('7')]]
offset: 7, exp: [[Decimal('2'), Decimal('7')], [Decimal('5'), Decimal('6')]]
offset: 6, exp: []
offset: 5, exp: [[Decimal('2'), Decimal('6')], [Decimal('5'), Decimal('4')]]
offset: 4, exp: []
offset: 3, exp: [[Decimal('2'), Decimal('2')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('2')]]
offset: 2, exp: [[Decimal('2'), Decimal('1')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: [[Decimal('2'), Decimal('3')]]
the powers in the 2's column go:
1, 2, 2, 2, 3, 3, 2, 4, 6
which are predicted by:
https://oeis.org/search/...
Again, probably only a coincidence, but kinda beautiful.2 
I watched an episode of Brooklyn 99. Cop comedy show for those of you who don't know. They introduced me to the monty hall problem? My brain refuses to understand it and im rapidly losing my mind.
Has anyone here ever written a program that tests it? I can't read math theorems for shit. But I can read code. And I need my sanity back.2 
heres a new constant found this morning
>>> (1.39094974939078**(pi0.5))1.39094974939078
==
0.9999999999999867
the following..
>>> 1.39094974939078**2
1.934741205330274 +/ 1
and
((1.39094974939078**(pi0)))
2.8198510518716056 +0/+1/+1
show up in things as varied as the density of galaxies, gasoline chemistry, traffic accident formulas, and more.
Kinda cool.31 
For any product of two nontrivial primes, it is *always* possible to get the quotient of its factors b/a derived solely from the product of those factors, *without* first factoring the product (p).
Fight me.3 
Just accidentally remembered my first encounter with Discrete Math... who knew hell could be a memory.

Happy halloween!
My halloween schedule
1. Start 3 new game projects
2. Study f***ing C for the test in coming Saturday and Sunday
3. Study math for the test in coming Sunday
4. Play werewolf in codrTalk (hopefully)
5. Start my f***ing logo after a disasterous fail.2 
If you ever have the pleasure of teaching kids (perhaps because they chose to stay home and pretend to be sick) teach them math.
Specifically teach them division. Have them divide 22/7.
Let them keep going until they ask 'when do we stop?'
And when they do, tell them: "you don't. It's an irrational fraction."9 
I finally got the lstm to a training and validation loss of < 0.05 for predicting the digits of a semiprime's factors.
I used selu activation with lecun normal initialization on a dense decoder, and compiled the model with Adam as the optimizer using mean squared error.
Selu is selfnormalizing, meaning it tends to mean 0 and preserves a standard deviation of one, so it eliminates the exploding/vanishing gradient problem. And I can get away with this specifically because selu *only* works on dense layers.
I chose Adam, even though this isn't a spare problem, because Adam excels on noisy problems and nonstationary objectives (definitely this), and because adam typically doesn't require a lot of hyperparameter tuning its ideal here, especially considering because I don't know what the hyperparameters should be to begin with.
I did work out some general guidelines on training quantity vs validation, etc.
The initial set wasn't huge or anything, roughly 110k pairs for training.
It converged pretty quick all things considered, and to the low loss like I mentioned, but even then the system always outputs the same result, regardless of the input, so obviously I'm doing something incorrectly.
The effectiveness of this approach for training and validation makes me question if I haven't got something wildly wrong. Still exploring though and figuring out how to get my answers back out. I'm hoping I just fucked up the output, and not the input as well. 
Hypothesis:
We may be able to determine if simple identities exist (say linked by a single variable or coefficient) for some subset of a set of variables S by comparing elements of the set and finding cardioid symmetries among them.
Yea or nay?
If someone is more familiar with the math and polar coordinates, I'd be grateful for your input.
https://pythontic.com/visualization...13 
Devrant help me out.
(n/x)*(y/x)
You know x, and you know n, and you know z where ((y/x)*x)*((x/y)*x) = z
Solve for y.
If you do it, I'll consider giving you a billion dollars (of course the payment schedule will be an asymptote).31 
I need your help... This is my 11 year olds math homework, one of the questions anyway... I cannot work it out.
Mrs choy spent exactly £10 on exactly 100 eggs.
Large eggs cost 50p
Medium eggs cost 10p
Small eggs cost 5p
For two of the sizes, she bought the same number of eggs.
How many of each size did she buy18 
Hey fellow nerds, I have a math question :)
I need to split a pile of coins (1s, 2s, 5s, 10s and so on) into a number of piles, let's say four, so that each pile has the same amount of money, but not necessarily the same amount of coins. Does anybody know of such an algorithm?7 
!rant
Currently I am studying "applied computer science" in Berlin and most of my modules are easy as fuck for me. Most of the time I don't even have to study for the exams. My programming professor even told me that I am the best student in terms of clean/readable code and he was amazed when I handed in on of my homeworks where I used MVC. Today I failed my math exam for the second time. It's the only module that I suck at, mainly because I don't give a fuck about it. I can easily grasp the concept of anything that I am interested in, but if I am forced to learn something my brain just shuts down. I truly fear that I will drop out of university because of math. I am still at my first of three math modules and I don't know how to handle this problem properly, having in mind that I still need to participate in two more modules. The saddest part is that I am not the only one with those problems and fears. I will link a news article of the German newspaper "Tagesspiegel" in the comments.
I know this is neither a rant or a question, but I just wanted to tell you guys about my problems and maybe start a conversation about the importance of math in our modern times and why school's aren't able to teach basic math in a way that young people are excited for it or at least are able to grasp the basic concepts.3 
So decided to build a board game... Game?
It's hex grid based and I have spent a week trying to work out hex grid math and I am at the exact point I was when I started if not further back....
If anyone can recommend some good tutorials or articles for hex math. I will love you forever...6 
So I made a couple slight modifications to the formula in the previous post and got some pretty cool results.
The original post is here:
https://devrant.com/rants/5632235/...
The default transformation from p, to the new product (call it p2) leads to *very* large products (even for products of the first 100 primes).
Take for example
a = 6229, b = 10477, p = a*b = 65261233
While the new product the formula generates, has a factor tree that contains our factor (a), the product is huge.
How huge?
6489397687944607231601420206388875594346703505936926682969449167115933666916914363806993605...
and
So huge I put the whole number in a pastebin here:
https://pastebin.com/1bC5kqGH
Now, that number DOES contain our example factor 6229. I demonstrated that in the prior post.
But first, it's huge, 2972 digits long, and second, many of its factors are huge too.
Right from the get go I had hunch, and did (p2 mod p) and the result was surprisingly small, much closer to the original product. Then just to see what happens I subtracted this result from the original product.
The modification looks like this:
(p(((abs(((((p)(9**i)9)+1))((((9**i)(p)9)2)))p+1)p)%p))
The result is '49856916'
Thats within the ballpark of our original product.
And then I factored it.
1, 2, 3, 4, 6, 12, 23, 29, 46, 58, 69, 87, 92, 116, 138, 174, 276, 348, 667, 1334, 2001, 2668, 4002, 6229, 8004, 12458, 18687, 24916, 37374, 74748, 143267, 180641, 286534, 361282, 429801, 541923, 573068, 722564, 859602, 1083846, 1719204, 2167692, 4154743, 8309486, 12464229, 16618972, 24928458, 49856916
Well damn. It's not asmooth or bsmooth (where 'smoothness' is defined as 'all factors are beneath some number n')
but this is far more approachable than just factoring the original product.
It still requires a value of i equal to
i = floor(a/2)
But the results are actually factorable now if this works for other products.
I rewrote the script and tested on a couple million products and added decimal support, and I'm happy to report it works.
Script is posted here if you want to test it yourself:
https://pastebin.com/RNu1iiQ8
What I'll do next is probably add some basic factorization of trivial primes
(say the first 100), and then figure out the average number of factors in each derived product.
I'm also still working on getting to values of i < a/2, but only having sporadic success.
It also means *very* large numbers (either a subset of them or universally) with *lots* of factors may be reducible to unique products with just two nontrivial factors, but thats a big question mark for now.
@scor if you want to take a look.5 
This morning, I tried to abstract myself from my computer while trying to calculate sqrt(1.81).
I came up with what I thought to be a genius method. I tried to find B such as (1+B)^2=1.81. Then I ended up calculating the discriminant of 1+2B+B^2 and had 4*1.81. Sounded funny at first, but upon calculating the positive solution amongst the 2 possible ones, I ended up with (2+2sqrt(1.81))/2 = ... sqrt(1.81)1. Upon replacing in the initial equation, one gets (1+sqrt(1.81)1)^2 = (sqrt(1.81))^2 = 1.81.
I'm sorry for having let you down, dear pasokon. Please forgive me.2 
Drop or be more flexible with the Math requirements. I took every programming course my High School offered including AP CompSci and passed with high grades. I wasn't able to pursue a degree because I wasn't "allowed" to take CS classes without first meeting the Calc 2 prerequisite. I am terrible with Math but programming makes sense to me, I'm good at it, and I enjoy it. I think it's horrible to stop someone from pursuing a degree because of a prerequisite. I understand the Math/CS relationship but being good at math doesn't make you a good developer. Just my opinion, I could be wrong.

Is writing handoptimized SIMD code even still worth it? Thinking about writing my own little math library for my game engine but I've tried writing a handoptimized `dot(normalize(b  a), foo) >= bar` and somehow it's actually slower than writing the same thing using a math lib which is implemented exclusively with scalar math and auto vectorized by llvm
LLVM... I kneel5 
https://i.postimg.cc/4ycRFNZf/...
The factorization shit I'm always ranting about? I decided for once to explain it visually in this handy dandy little infographic.
We're essentially transforming the product from an unsmooth set of potential factors in its factor tree, to a factorization tree that guarantees first that the set of potential factors are all 2, 3, 5, and a or b of p, and second, that all the factors are *smooth integers* of a or b.
This is basically what Adi Shamir was trying to do with TWINKLE and TWIRL, despite checking a hundred thousand+ potential primes.
I did it in four.7 
So I heard to get a job as a programmer you need a degree in computer science. I looked it up and apparently computer science includes alot of math courses. I'm not good at math and as far as I can see complex math is not needed to be a programmer. Is there any other degree I can take to get a job as a programmer that doesn't require as much math as a computer science degree does?14

This year when I started highschool because I'm at the, uh, mathcomp sci, I guess, profile.
(Here in Romania there are highschool profiles that add specific objects to be learned, also mathcomp sci is the only translation I can think of for mateinfo)2 
Suggestions for cool/fascinating math problems that are hard to solve, but if done correctly can be performed very efficient? Wanna build some puzzles and need some ideas :)3

What do you call a function based on (w*x) / (y*z)
where w and y remain the same, and x always increases linearly with z?
For example
at one point on the graph it might look like
(60*1) / (25*1)
and on the next it equals
(60*2) / (25*2)17 
Its everyones favorite time again. Wisecrack's 8th grade hoborants about mathematics.
Lets start with the example
a=89
b=223
p=a*b=19847
If
(1/(5/p))/b = 17.8
and naturally
p/5 =3969.4
3969.4/b = 17.8
What I find interesting is that...
p/17.8 = 1115.0
..for any product and factors (given two factors), the result will always be an integer.
Why is this?
You can see that
t= 1115.0*b = 248645.0
And if
17.8*(p/a) = 3969.4
Then
17.8*(t/p) = 223.0 (our factor, b)
a*(t/p)
1115.0
p/1115
17.8
also a*(t/p) = 1115.0
I could be once again misunderstanding but
what it looks like is that theres some real number that always transforms p into an integer on the ring of integers (Z) representing multiples of the factors of p.
Now notice
b/17.8 = 12.52808988764045
We can also get that number like so..
t/p = 12.52808988764045
I think (though I could be mistaken) is that the reason is because t is b*1115 and 12.52808988764045 is the ratio between b and 17.8 as well as the ratio between
p and 1115.
And if we do
t/√p = 1764.9495488858483
1764.9495488858483^2 = 3115046.9101123596
also incidentally
3115046.9101123596/t =12.52808988764045
3115046.9101123596/12.52808988764045 =
t (this is obvious but I want to point it out anyway), or 248645.0
and
1115/b = 5.0
248645.0/5 = 49729.0
and
√49729.0 = b
Why is this last part true, that √(t/5) = b?11 
Established a new *much* tighter bound on the value of the D(10) dedekind.
Pasted code here:
https://pastebin.com/xYSND9NN
It's almost beyond doubt to be located somewhere between 10^75 and 10^77. 
Only math would be so bold to use an undefined value/parameter name as the argument for a function. I gave it an Uncaught ReferenceError.1

Now I can think more logically. I was worst at math, like ever. But programming made me think more deeply and that boosted my math scores. Still, I am peace of shit, just digital.

My teachers saied: Math is important for the programmation...
We are now learning some shit that is useless. We only need Multiplication, Division and Addition (and sometime ²)...14 
Let some number P be the product of two factors, A and B
Let the iterations of A*1..2..3..N up to B+1 be a directed graph.
Would this graph be eularian?
If so then it should be possible to use the BEST algorithm to count the number of eularian circuits, yielding B, no?
Edit: this is supported by the following text:
An arborescence can equivalently be defined as a rooted digraph in which the path from the root to any other vertex is unique.
* * *
Where the product of any two primes is unique, the path to it across our graph here, is also unique. 
Whats it called when you subtract 1 or more from a number and get its decimal component back as result?
For example, lets say
((x+y)/y)  1 == x/y
For example
((x+y)/y) == d('1.000041160213365071474861471983496528380123531238424473420976789')
and the right hand side is
(x/y) == d('0.000041160213365071474861471983496528380123531238424473420976789')
Is this trivial or something interesting or a concept that others are familiar with and I just haven't learned?7 
I know it's not really related to development, but I got in a discussion on twitter and one dude tweeted "in science, 1 isn't 1"
And so I was like "mate what? science is highly dependent on math and in math, 1 is kinda always worth math"
And this this girl comes in and just says:
"it's not true that 1 is always 1 because there's binary code as well"
And was was like totally astonished, like, have you even studied something? 1b = 1d = 1x and it's always 1 in whatever base!
(she even says she's some sort of engineer in her bio)8 
Commit message of the day: "Until the [some KPI] can be stored with 15+2 digits in the middle ware, we store its logarithm (to the base of 2) with 3+2 digits."

Is there actually a proper way to do Math in Javascript, without parsing every value to avoid something like
"1" + 3 = 13 ?rant trying to learn proper math start to hate dynamic var types wtf is going on with that language javascript advice needed11 
Heres a fairly useless but interesting tidbit:
if i = n
then
r = (abs(((((p)(9**i)9)+1))((((9**i)(p)9)2)))p+1+1)
then r%a will (almost*) always return 0. when n = floor(a/2) for the lowest nontrivial factor of a two factor product.
Thats not really the interesting bit though. The interesting bit is the result of r will always be some product with a *larger* factor tree that includes the factor A of p, but not p's other larger factor, B.
So, useless from what I can see. But its an interesting function on its own, simply because of what it does.
I wrote a script to test it. For all twofactor products of the first 1000 primes, (with no repeating combinations, so if we calculated say, 23*31, we skip 31*23), only 3262 products failed this little formula, out of half a million.
All others reliably returned 0 for the following..
~~~
i = floor(a/2)
r = (abs(((((p)(9**i)9)+1))((((9**i)(p)9)2)))p+1+1)
r%a
~~~
The distribution of failures was *very* early on in the set of factors, and once fixed at the value of 3262, stopped increasing for the rest of the run.
I didn't calculate if some primes were more likely to cause a product to fail or not. Nor the factor trees, nor if the factor trees had any factors in common between products, or anything of that nature.
All in all I count this as a worthwhile experiment.
If you want to run the code yourself, I posted it to pastebin here:
https://pastebin.com/Q4LFKBjB
edit:
Tried wolfram alpha just to see what it says, but apparently not much. Wish it could tell me more.40 
Watched UFO 2018.
Movie mostly about guy trying to solve math problem but nice.
Learned about finestructure constant and that all base SI units were redefined in 2019 lol.
I don’t remember anyone mentioned that scientists changed all of standardized measurements.
Overall nice movie if you like those about solving imaginary problem without special effects etc...
Looks like nobody cares how much kilogram weights.7 
is this what they call an identity?
log(n, n**(1/n)) == n
first argument in log is the value
second argument is the base10 
This is some cool shit:
https://arstechnica.com/information...
Now I want to learn how to AI at least enough to understand what they are doing.
People worried about AI replacing programmers when it was the math people software has been replacing.6 
Hang with me! This is *not* a math shitpost, I repeat, it is NOT a math shitpost, not entirely anyway.
It appears there is for products of two nontrivial factors, a real number n (well a rational number anyway) such that p/n = i (some number in the set of integers), whos factor chain is apparently no greater than floor(log(log(p))**2)2, and whos largest factor is never greater than p^(1/4).
And that this number is at least derivable, laboriously with the following:
where p=a*b
https://pastebin.com/Z4thebha
And assuming you have the factors of p/z = jkl..
then instead of doing
p/(jkl..) = z
you can do
p(jkl) to get the value of [result] whos index is a1
Getting the actual factor tree of p/z is another matter, but its a start.
Edit: you have to provide your own product.
Preferably import Decimal first.3 
my head complains about lack of trigonometry and too many variables. and it's just about drawing and positioning some circles. no 'real' math.1

https://brilliant.org/wiki/...
Is a fascinating breakdown for anyone interested in complex numbers but intimidated by complex *math*.
They really go over it step by step. Take a look 
Writing 4 exams this week in math / computer science, I am super nervous. Any tips to stay calm? :)9

!rant
Today i had my first class of this semester. Meanwhile, there was a small party on campus. I was having math class "listening" a playlist with "Stayin' Alive" and "I Will Survive".
Best soundtrack to my class :D5 
was doing a matrix determinant solving and came across this method of solving it via gaussian elimination. just one question, WHY?
there's the simple method of solving them, why to use complex stuff. ://6 
so my friend got told he had to stay after school for math every day he had math to catch up on work but this idiotic teacher told him he had to stay every tuesday and thursday...the only days this week he didnt have math class, yeah our school system sucks

So, today I was helping my cousin with his math homework, then I realized he had found the equation for a sequence of numbers taking the first index as 0 ... I never been so proud in my life.
It was wrong tho :(rant tagz tagy linux index zero rules math tagx more popular stuff pichardo for president javascript2 
!rant
For the first time since I started work I used a matrix to find a formula.. Albeit it was for jquery.
Those hours and headaches spent studying math are paying off. Feeling a bit proud... 
Im very proud of myself for getting on scratch and putting in 200+ Code Blocks for 2 hours straight. Working on it to help an elementary school better teach math since I have a mild case of ADHD which made it challenging to learn. Hopefully this game will better help kiddos like i was, learn math easier. Will send out an update when its finished with the link to it.2

Any good algo book for a guy who's managed to read C Primer Plus and Learning Python? With math really explained. He's bad in math.7

I fucking hate math. Today tried to make 2 unequal rectangles align along 1 axis. This isn't that hard when they aren't rotated but it fucking when they are rotated. I know I have to use geometry to get them aligned and I got it somewat working but as the gap is bigger so is the drift in which it over compensates to the other side and I have no fucking clue how to fix this 😩.
The worst thing is tomorrow I have to be at this again1 
I want to run a simulation like rolling a dice N times and find out what's the distribution/probability of getting certain SUMs after the rolls.
However the dice is more likely to land on a lower number, and/or depends on what the number it landed on previously.
Stats wise I think ideally I want to be able to just input the avg, standard deviation, and skewness into a Random class constructor, and then ask it for N "random" numbers.6 
Before i get my degree i have to write my finishing thesis on blockchain topic, has to include something about using math from linear algebra or math analysis that is applied to blockchain, can anyone give me links of similar examples of finishing thesis of this for inspiration?8

Im starting on computer science study this summer. Im reading up on mathematics and taking a higher math exam aswell. But ive come to wonder. How much math would you really be using as a computer scientist? And any area of math i should pay specific attention to?1

Anyone here familiar with the LibreOffice codebase? Cause I want to modify Math to be used as a formula database.1