test(a,b#) // fn name
// Code
x:a+1
y:b#-1 // subs # by local
cond:1

// while loop
while cond1
// for loop
for k,rng
r:19
s:20
try a
b
if cond2 // if(2)
t:21
if cond3 // if(3)
t:21
else
u:22
if cond4 // f(4)
t:21
elif cond4'
u:22
else
v#:23

m:mat( ... // continue
x,y, ... // in
r,s, ... // next line
2,2)

m+v#

RREF(M) // Rew reduced echelon form
r:1 & c:1 // use and or stack() for
A:M & B:A // simulate line break
m:rows(A) & n:cols(A)

ro:range(1,m)
while (r≤m)&(c≤n)
if el(A,r,c)≡0
h:range(r,m)
el(A,h,c):0
c:c+1
else
k:range(c,n)
f:el(A,r,c)
el(A,r,k):el(A,r,k)/f
el(B,ro,k):el(A,ro,k)- ...
if(ro≠r,el(A,ro,c)*el(A,r,k),0)
el(A,ro,k):el(B,ro,k)
r:r+1 & c:c+1
A

Bisection(f(1),α,β,ε) // Bisection method
a:α & b:β
fa:f(a) & fb:f(b)
if sign(fa)*sign(fb)>0
error("Wrong interval")
else
if fa≡0
c:a
else
if fb≡0
c:b
else
N:1+trunc(log(abs({b-a}/ε),2))
for iter, range(1,N)
c:{a+b}/2 & fc:f(c)
if fc≡0
break
else
if sign(fa)*sign(fc)>0
a:c & fa:fc
else
b:c & fb:fc
c

RK(D#(2),xo#,to#,te#,N#,ε#)

// Runge–Kutta method
// with adaptive step

X#:xo#
h#:{te#-to#}/{N#+1}
for t#:to#+h#,t#≤te#+to#+h#,t#:t#+h#
x#:col(X#,cols(X#))
k1#:h#/3*eval(D#(t#,x#))
k2#:h#/3*eval(D#(t#+h#/3,x#+k1#))
k3#:h#/3*eval(D#(t#+h#/3,x#+{k1#+k2#}/2))
k4#:h#/3*eval(D#(t#+h#/2,x#+{3*k1#+9*k3#}/8))
k5#:h#/3*eval(D#(t#+h#,x#+{3*k1#-9*k3#}/2+6*k4#))
δ#:k1#-9/2*k3#+4*k4#-1/2*k5#
if normi(δ#)≤5*ε#
X#:augment(X#,x#+1/2*(k1#+4*k4#+k5#))
el(T#,1,cols(X#)):t#
h#:h#*2
else
t#:t#-h#
h#:h#/2
transpose(stack(T#,X#))

if2(x)

if x>0
ans:ln(x)
ans

if3(x)

if x>0
ans:ln(x)
else
ans:ln(-x)
ans

if4(x)

if x>0
ans:ln(x)
elif x<0
ans:ln(-x)
else
ans:-∞
ans