simplifier

;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, and 0.1+0.2 isn't 0.3:
out = 0.1 + 0.2
// 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 (approximately) pi and e, along some tmp variables that will be used later.
pi = 3.1415926535897932384626433
e = exp(1)
tmp = tmp1 = 0
// Equals (=) is chainable: when tmp = tmp1 = 0 is calculated, it goes through these steps:
// convert to expression and get tmp = (tmp1 = 0), because = is right-associative, so () goes on the right
// calculate tmp1 = 0, so set tmp1 to 0 and resolve to tmp = 0 because (x = y) resolves to y
// set tmp to 0 and technically resolve to 0
// You can check all variables with ;checkvars:
;checkvars
// Note that variables are not saved across runs: 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 37:
round(2*(0-5/3*e^pi*sin(max(6*7,2.1)))-7/2-e^(0-2)-30)
// You can see that it has rounding, exponents, subtraction, trig, min/max, and a usage of e and pi from earlier.
// 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, and == compares.
// Anyways, for all operations here, see below.

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, exponents only reduce when used with integers more than 0 or (sometimes) the inverse of those
if you want to write 1/3, DO NOT WRITE 0.3333333. instead, just write (1/3). well, IEEE-754 point will round it, but oh well.
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
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
= (x=y): the x is defined as y
also = (x==y): checks if x is the same as y
> (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
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
error messages with full subject-verb agreement (in English at least), without using (s) to cheat (yes I did waste like 10 minutes programming all 3 cases)

changelog (new.bugfix)

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
0.0: "forked" from crappy SLM prerelease