My boss has been begging me migrate a nightmarish complex excel report he made to calculate the payout of a tiered rebates program with compounding rewards. Today I finally decided to make take the time and I sat down with him so he could break it down for me...

Me: *looking at the mess of formula's* it would be easier to rewrite the math than decode this - can you just give me the reward rules... where does that value in cellX come from?

Him:*pointing at the spreadsheet* There! All the rules are in there for you :-)... like it's some big favour...

Me:No I mean when you wrote this, what did you base this off? There must be something...

Him: *Very Gravely* No, no, no it's far to complex! It took me ages to get this sheet right and it balances so just trust me and use it ok?

At this point I will mention he's an accountant so yeah I fucking trust him... fast forward past 15 minutes of digging through what may as well be quantum theory and lo and fucking behold all 2 sheets and 100 calculations are mathematically fucking pointless. Aside from formulas like this:
$X10=+(((O10+P10)-((O10+P10)*$X$3))*$R$4)+T10
which is actually equal to (X10/R4)/L10.

Anyway once you compound and sum the "tiered" benefits the rewards payout is ALWAYS = customerSpend*1.81.

This is why programmers name variables.

So here I am sitting on my dusty laptop gaming laptop (because supposedly it would offer me better performance in compiling code and working with CUDA according to the people above me) at a research institute where I just started working at. I am told that there are some issues with the code and that it fails to build on Windows with MSVC that ships with Visual Studio 2017 and later.

I poor some hot tea from my insulated bottle I brought from home and start reading.

I look in this header file and what do I see - a custom uint24_t struct. Interesting...

I keep sifting through the code base. I find some functions that check and change Endianess. Ok, but the software is developed, built on and runs only on Win7 and later desktop systems. Never mind...

Further I find a custom "allocator" that is used throughout the whole code base. It has three inline static class member functions: allocate, copy and deallocate plus some private constructors. And these just wrap around the standard new and free calls. Some flavours of this class actually only deallocate (with a comment above them: "This allocator does not allocate. HANDLE WITH CARE!!!", which is btw the only "code documentation" I have managed to find).

But wait! What is this? A custom thread and mutex. Oh, and string, and vector.

Further down the rabbit hole I find a custom math library with a matrix class that does not support multiplication between a matrix and a vector. Perhaps not a use case I guess...

I continue and come across some UI-related calls. Interesting, I wonder what they are using as a framework. Oh, my...We have an extensive GUI custom framework written from scratch (drawing buttons and all).

All of this is to load an OBJ file and render it on the screen on a standard Windows PC in some way.

Very nice... ;_;

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 b-smooth 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.

How hard can it be to make a calculator app. Apparently Microsoft cannot get it right. You might say hey, but it works already. No it does not. See in math 1-(-1)=2 because the double minus sign cancel each other and turn into a plus. Well the w10 calculator app, just does 1-1=0 and show that this is the result. Yes this is the result of one minus one. This is not the result of one minus minus one. This is basic math .... Stop focusing on the interface and code the base right Microsoft.

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.30000004

I've been away a while, mostly working 60-70 hour weeks.

Found a managers job and the illusion of low-level 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/(n-i))+(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 p||q 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.

I'm curious, how many of you ranters out there studied Math at an advanced level to become proficient at programming? Is there a particular field of Mathematics that would improve my programming skill?

Context: I come across a lot of Math I don't understand/never encountered when researching topics such as encryption, hashing, geospatial data handling and randomness. Was wondering if I missed out on some key learning that would make these topics a lot less mysterious. Also, I overheard someone coming up with a mathematical formula to base an algorithm on. I don't think I've ever come up with algos this way.

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)

Watched UFO 2018.
Movie mostly about guy trying to solve math problem but nice.
Learned about fine-structure 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.