calcufier

;l BASICS
// This is an infix notation calculator.
// If you want to just do a normal calculation, just do:
out = 1+1
// (though 1+1 can be replaced with basically anything).
// As you can tell, // denotes a comment. These aren't calculated:
// out = 2763 (2763 won't appear)
// If you have more than 1 expression, they will be put top to bottom:
out = 9+10
// Since ;l BASICS outputted BASICS (we'll get to that later), out = 1+1 outputted 2, and out = 9+10 outputted 19 (not 21), the output should start with:
// BASICS
// 2
// 19
// Oh, also, x^y^z is evaluated like x^(y^z), not (x^y)^z:
out = 2^1^3
out = (2^1)^3
// That is all you should need to know usually. However, this calculator can do more.
;l
;l VARS
// Something important is that you can set variables.
// For example, this is e and phi, along with some tmp variables.
e = exp(1)
phi = (1+sqrt(5))/2
tmp = tmp1 = 0
// Only pi is predefined: you have to define e and phi if you want to use them, for example.
// Equals (=) is chainable: when tmp = tmp1 = 0 is calculated, it actually does tmp = (tmp1 = 0), and x=y evaluates to y.
// You can check all variables with ;checkvars:
;checkvars
// Note that variables are not saved across seperate calculations: if you delete all of this text and try out = tmp, it won't work, because it is no longer defined.
// Also, out can be used as a variable:
out = out
;l
;l SPECIALS
// You may have noticed that 2 types of things here start with ";", so far just ;l and ;checkvars.
// These are in the category of specials: they are not expressions or equations, and instead do special things.
// For example, ;l outputs whatever is after it, with further ;s replaced by spaces:
;l The;quick;brown;fox;jumps;over;the;lazy;dog.
// You'll notice that an actual space doesn't work: the code removes spaces, repeated newlines, and tabs, before tokenizing. In fact, you can do this:
;l The     ;             quick;b   r  o  w n   ;  f ox     ;ju   mps; over ;  the  ; la     zy     ;      dog.
// and it will still look the same in output.
;l
;l ADVANCED;OPS
// So far, we have only seen addition. Of course, this calculator can do any expression (although you must write 0-2 instead of -2, for unary negation is hard to parse).
// For example, this expression evaluates to 28:
out = round(89-37*(0-5/3*e^(pi)*sin(max(6*7,(21/10))))-7/2-e^(0-2))
// You can see that it has rounding, exponents, subtraction, trig, min/max, and a usage of e and pi from earlier.
// Now of course, floating point, the system used for computing results, cannot do this percisely. In fact, 0.1+0.2 = 0.30000000000000004:
out = 1/10+2/10
// Wait, what? It's 0.3. That's because, before calculation, this calculator simplifies expressions: it's a calculator+simplifier (a calcufier). 1/10+2/10 becomes 3/10. This, when evaluated, gives 0.3, along with \frac{3}{10}, which is LaTeX for 3/10. In fact, those expressions with { and } are things in LaTeX, so you can paste them into Desmos.
// Another example, which would normally output 2.0000000000000004:
out = sqrt(2)^2
// Variables have their value saved as an expression, which in the simplification stage allows for more accuracy:
root2 = sqrt(2)
out = root2^2
// The list of simplification rules is below the list of supported operations.
// However, this calculator can do things beyond just arithmetic. For example, boolean logic exists:
true = 0==0
false = 0==1
out = !(true&false)
// Just remember that = and == are different: = sets things, and == compares.
// Now, of course, you can combine these:
if(9==2+7,out=1,out=0)
// This prints 1, because 9 does, in fact, equal 2+7, however it does not print 0, because only the if branch is evaluated, not the else branch.
// For all operations here, see below.
;l PROGRAMS
// Since there is an if, why not have loops? Yes, this is technically a programming language. For example:
x = 28
;g 0
out = x
if(x%2==0,x=(x/2),x=(3*x+1))
if(x==1,0,goto(0))
out = x
// This program calculates the collatz sequence. ;g marks a goto number, and since it's 0, evaluating goto(0) will jump there. This actually calculates things: if you set x to 27 and have a good computer, you'll get a lot more numbers, as expected. Just, be very careful not to cause an infinite loop: since the halting problem is undecidable, the calculator cannot determine if you've made an infinite loop, and if you do, your computer might crash.
// But anyways, this also shows some things: you can set a variable to an expression containing itself (because the expression you set it to is simplified), and you can use if statements to create control flows. These are both important, as together, you can emulate Rule 110 (or Rule 54), meaning that this calculator is Turing complete. Unfortunately, an actual emulator would be an infinite loop, so you'd have to make more variables to make it finite.
// Labels can be used for functions, although since I have yet to implement strings, they're numbers:
goto(2)
// sinExp (base-36 -> base-10 convention here)
;g 1724378461
z = sin(x^y+x)
goto(w)

// start
;g 48396233
x = 5
y = 6
w = 1657494275
goto(1724378461)
// return
;g 1657494275
out = z
// Currently however, this language is more of a somewhat low-level computer algebra language, and you might as well use javascript. However, this does mean you can run Doom and Bad Apple!! on a CAS, so...

A calculator! Just put your expression or expressions in, and it'll simplify them (using radians). Instructions are in default expressions.

no commas in numbers
1^2^3 will be interpeted as 1^(2^3)
unary negation (like -x) must be written as 0-x
for now, the laws of exponents haven't been implemented
if you want to write 1/3, DO NOT WRITE 0.3333333. instead, just write (1/3). in fact, decimals won't work here.
ofc this is buggy, and if you just need normal calculation use Desmos or wolfram alpha

This calculator suppourts the following:

succesor (S(x)): adds 1 to a number (no, I don't actually use peano axioms for this)
addition (x+y): if y is 0, is x, if y can be written as S(z), is S(x+z), and will generalize to non-natrual numbers
subtraction (x-y): if x-y=z, then x=y+z
multiplication (x*y): if y is 0, is 0, if y can be written as S(z), is x*y + x, will generalize to non-natrual numbers, and by default evaluated before addition and subtraction
division (x/y): if x/y=z, then x=y*z
modulos (x%y): 2&6 = 8%6, basically wrap-around for math, not to be confused with remainder (they are same for positives tho)
exponentiation (x^y): if x and y are 0, is 1 (deal with it), if x isn't zero and y is 0, is 1, if y can be written as S(z), is x^y * x, will generalize (for the most part) to non-natrual numbers, and is by default evalutated before addition, subraction, multiplication, and division
parentheses ((x)): is the value of x, even in situations like 5*(4+7), where addition would otherwise go before multiplication
also parentheses ((x,y)): used for inputs of things like min(x,y), to show 2 inputs, and also would make parsing numbers with commas too hard
min (min(x,y)): if x is less than y, x, otherwise y
max (max(x,y)): min but greater than instead of less than
abs (abs(x)): the euclidean distance from 0 to x
if (if(c,i,e)): if c is true, i, otherwise e
goto (goto(x)): goto the line with the neumeric label x
= (x=y): x is defined as y
== (x==y): checks if x is the same as y (abstract equality)
> (x>y): checks if x is greater than y
< (x<y): checks if x is less than y
>= (x>y): checks if x is greater than or equal to y
<= (x>y): checks if x is less than or equal to y
!= (x!=y): checks if x is not equal to y, and works as xor
& (x&y): only true if x is true and y is true
| (x|y): only false if x is false and y is false
! (!(x)): only true if x is false
exp (exp(x)): e^x
ln (ln(x)): the value y such that e^y = x
log2 (log2(x)): the value y such that 2^y = x
log10 (log10(x)): the value y such that 10^y = x
log (log(b,x)): the value y such that b^y = x
sqrt (sqrt(x)): the number that, when multiplied by itself, is x
cbrt (cbrt(x)): the number that, when multiplied by [itself multiplied by itself], is x
nthroot (nthroot(n,x)): the number that, when multiplied by itself n times, is x
round (round(x)): the integer closest x
sin (sin(x)): let's say I have an arrow starting at the center of a circle whose radius is 1 meter, and it is rotated (starting from pointing +x, counterclockwise, around the center of the circle) by an angle of θ, where if θ=τ we rotate 360 degrees, then sin(θ) is the y coordinate (how far up/down) of the arrow's tip
cos (cos(x)): sin but x coordinate (how far left/right)
tan (tan(x)): sin(x)/cos(x), or the distance you must travel going only in the direction the circle was curving when yiu started to get to the x axis starting from the point where your rotated arrow touches the circle
asin (asin(x)): the number θ closest to 0 such that x=sin(θ)
acos (acos(x)): asin but cos
atan (atan(x)): asin but tan
atan2 (atan2(x,y)): the angle you must go to get to the point (y,x), calculated as atan(y/x) with a whole load of exceptions where atan(y/x) would break
comment (//x): if a line starts with //, it is ignored

The simplification rules are:

a=b -> a=b (only simplify RHS (you can't see it there, but b is simplified and a isn't))
a, a=b -> b (substitution)
a+a -> 2*a (double)
a*b+b -> (a+1)*b (mul 1 and distribute)
a*c+b*c -> (a+b)*c (distribute (works if addends are flipped))
(a+b)*(c+d) -> ac+bc+ad+bd (FOIL)
a+B -> B+a (const first)
a*B -> B*a (const first)
a/b, a>=0, b>0\=0 -> (a/GCD(a,b))/(b/GCD(a,b)) (fraction reduction)
a/b, b<0 -> 0-a/(0-b) (fraction reduction)
a/b+c/d -> (ad+bc)/bd (fraction addition)
a/b-c/d -> (ad-bc)/bd (fraction subtraction)
a/b*c/d -> ac/bd (fraction multiplication)
a/b*c/d -> ad/bc (fraction division)
(a/b)^c -> a^c/b^c (fraction exponent distrib)
x^1 -> x (x^1)
x^0-> 1 (x^0)
x^-1 -> 1/x (x^-1)
sqrt(x) -> nthroot(2,x) (sqrt def)
cbrt(x) -> nthroot(3,x) (cbrt def)
nthroot(n,x)^n -> x (exp undo root)

where capital letters are constants, along with computation when exact for BigInts and booleans. These simplifications can be seen in the console.

changelog (new.bugfix)

2.2: if and goto
2.1: more simplification rules
2.0: 0.1+0.2 no longer equals 0.30000000000000004: it is EXACTLY 0.3. in fact, this calculator has a simplification step!
1.0: added variable definition, fixed 1+1 equaling 11, and made a whole new instruction manual... and oh geez this thing is nearing gravity simulator in length lol
0.0: "forked" from crappy SLM prerelease