Pretty Function

macOS Apps

A Powerful, Programmable Calculator

SL is a powerful, programmable calculator, with an easy-to-learn programming language.

App Store

SL is a powerful, programmable calculator with full trigonometric and logarithmic functions. It has an easy-to-learn programing language. You can write programs, save and use them later; this enables you to save time and to avoid making mistakes.

Write code to evaluate and render complex mathematical expressions. Define variables to create expressions. Render expressions easily with MathML. Use flow control and iteration statements to perform conditional and repeating computations. Compute expressions involving row, column, and matrix vectors. Define discrete signals, convolve them, and plot their graphs. Use output statements to display the results of computations.

Examples below demonstrate how useful SL can be when solving problems in physics, when formatting mathematical expressions, and when convolving discrete signals.

Example 1

You are solving problems involving objects in uniform motion, motion under constant acceleration. You want to calculate the force required to stop an object in a given distance. The mass of the object and its speed are given. To do this, you would use the equation of kinematics that defines velocity as a function of displacement, and you would solve that equation for the acceleration required to stop the object in the specified distance. Then you would use Newton's second law to calculate the force required.

v2 - v2
0 = 2a(x - x0)

∴ a = (v2 - v2
0) / 2(x - x0)
F = Ma

You would then write code for expressions to compute the last two equations above. Finally, you would save the program so that you can use it later.

Here is the SL code for it.

M  := 2000.0 // kg  - mass of the object
v0 := 100.0  // m/s - inital speed of the object
v  := 0.0    // m/s - final speed of the object
x0 := 0.0    // m   - inital position
x  := 80.0   // m   - final position, the stopping distance

// Acceleration
a := (v - v0) * (v + v0) / (2.0 * (x - x0))

// Force required
F := M * a

// Print
$T << F << " N"

Example 2

You are solving heat-transfer problems. You want to compute how much energy (in joules or Calories) is required to boil 1.6 liters of water in an electric kettle. You would first write an expression for the specific heat equation and then compute it with given parameters.

Q = McΔT

Here is the SL code for it.

M  := 1.6     // kg - mass of 1.6 liters of water
T1 := 15.0    // degrees celcius - initial temperature of water
T2 := 100.0   // degrees celcius - final temperature
c  := 4186.0  // joules / (kg degrees celcius) - specific heat of water

// Increase in temperature
DT := T2 - T1

// Energy required - in joules
Q := M * c * DT

// Print
$T << Q << " joules"

Example 3

Render a complex mathematical expression with MathML.

The following SL code renders the above expression with MathML.

// Render mathematical expressions with MathML

_x := $M (variable, "x")
_y := $M (variable, "y")
_1 := $M (number, 1)
_2 := $M (number, 2)

op_color  := "color FF55AA"
op_size   := "size 1.0"
var_size  := "size 1.5"
expr_size := "size 2.5"

plus := $M (style, $M (operator, "+"), op_color, op_size)
minus:= $M (style, $M (operator, "-"), op_color, op_size)

_x = $M (style, _x, var_size)
_y = $M (style, _y, var_size)

_x_2 := $M (sup, _x, _2)
_y_2 := $M (sup, _y, _2)

_expr1 := _x + minus + _y
_expr2 := _x_2 + plus + _y_2

_expr3 := $M (group, _1, plus, $M (frac, _expr1, _expr2))
_expr  := $M (frac,  _1, _expr3)

_expr  = $M (style, _expr, expr_size)

$T << $^ << _expr << $$

Example 4

Convolve discrete signals.

The following SL code demonstrates how to define discrete signals, how to convolve them, and how to graph them.

// Convolve discrete signals

// Define impulse
p (n) := 1

// Define input signal
s (n) := p (n+1) + 2 * p (n) + p (n-1)

// Defined impulse response
h (n) := p (n+2) - p (n+1) + p (n) - p (n-1) + p (n-2)

// Define output signal - convolution of input and impulse response
y (n) := s (n) * h (n)

// Graph
$S {{s (n)} s (n) {h (n)} h (n) {y (n)} y (n)}

Here are the graphs of the signals.

Impulse response

Input signal

Output signal - Convolution of the input signal and impulse response.