ComputeSoup is an expression evaluator. It evaluates the user's
input expression and tabulates the result and variable values for up to
eight variables (each with one or more values).
194 Constants (e.g., PI, SQRT2) and 226 Functions
(e.g., Sqrt, Refinance, Cubic, Payoff, Complexdiv, Ira, Integrate) are
available for use. Click the
Constants
button for a list/description of the available constants, or the
Functions
button for a list/description of the available functions.
There
are several features which can make using the basic functionality
of expression (and equation) evaluation easier. Among these
features:
An equation is a simple variable followed by "=" followed by an
expression. The expression may contain variables,
constants, and functions. The result of each expression
evaluation (one for each set of variable values) is saved in
the Store under the left hand side variable name. When that
variable is next referenced in an expression, those saved values are
automatically loaded (although they are subject to user override).
Here is a simple sample of an equation:
omega = (rho-a)*sin((pi-rho)*(1-a));
For this sample, the user would be prompted for one or more values for
the variables rho and a. If the user entered two
values for one variable and three for the other, six values for
omega would be calculated and saved in the Store.
When omega is later used in the same session, these
six values would be automatically loaded.
It is straightforward to load variable values directly into the Store
for use later in the session. The format is $var
= value[s] -- later you can use var
in an expression without needing to enter values. Here are some
examples:
$e = enatural
$i = 1, 2,
3, 4
$index = loop
1 17 2
$beta = 5.103,
4.1219, pi, 2.171, sqrt3
$xyz = interp
3 7 4
In these examples, values for e, i, index,
beta and xyz are placed in the Store.
Enatural, pi and sqrt3 are constants (click the
Constants
button for a list/description of the available constants), and
loop and interp are special input shortcuts. The
values for index are 1, 3, 5, ..., 17. The values for
xyz are 3, 3.125, 3.25, ..., 3.875, 4. That is, seven
equally-spaced values are placed between 3 and 4, making nine values
total. Details about loop and interp can be
found below, or by clicking the
Input Shortcuts
button, which can also be found via the
button.
Several user-settable options control various aspects of displaying
results and saving information in the Store. Clicking the
[Options] button above yields the following matrix of options:
Alternate Bases
Save
LHS
Append
Save
RHS
Extra Precision
Show FYIs
Hide History
Show Stats
Ignore Store
Warnings
Save
History
Zoctal
Any of these options can be turned on or off.
By default, all left-hand-side (LHS) variables are saved in the Store.
Click the save right-hand-side [Save RHS] box,
then the [Apply] button to save the
values of your input variables for later reuse.
Equations and expressions entered in the [Expr] box are saved
in a history file (the History dropdown menu) for the duration
of the session. Any of them can be recalled for resubmission
or editing and reuse. Note that the History dropdown
menu only appears after an expression has been entered.
Here is a simple sample of the History dropdown menu (note
– the menu is most-recent-first):
The Store holds variables and user-defined functions. It
persists for the lifetime of the session. Various usage statistics
are maintained for the data stored in the Store. The most useful
information maintained in the Store is the data saved for user-defined
functions and the values of variables. Variables and their
values are sent to the store as the result of Equation Evaluations
(when the SaveLHS option is On), when direct Store requests are
made (e.g., "$iter = 2 4 6 8 12 16 22"), and when variables are
used in an expression while the SaveRHS option is On. By default,
SaveLHS = On and SaveRHS = Off. These values can
be changed by clicking the [Options] button.
When there is data
in the Store, a Store button will appear in the matrix above the
[Expr] box, as below:
When data is saved in the Store, clicking the [Store]
button displays a panel (as below) which allows the user to manipulate
and report on the contents of the Store. Note that deleting a
variable or a user-defined function is final – that is, no
recovery is possible. However, variables can be
deactivated and later activated. While a variable
is deactivated, ComputeSoup behaves as if it does not
exist. At creation, all variables are activated.
When an expression contains a variable which is in the Store,
ComputeSoup automatically loads its values. Thus the results
of previous computations can be easily used in subsequent
expressions. The user is able to override these values.
Data in the Store is automatically used (although the user may override
some or all of the previous values). Here is a sample: Assume that
index is in the Store with values 1,3,5,...,17 (as above).
Then entering dist = index*(pi-theta) in the [Expr]
box and clicking [Go] would lead to:
dist = index*(PI-theta);
Enter value(s) for each variable
index
theta
Note that the yellow box indicates that the values have been withdrawn
from the Store. These values may be accepted, deleted, or
overridden for this evaluation.
Input values may be integers, floating point values, or
ComputeSoup-recognized constants (like pi or sqrt2).
Input values are separated by one or more commas, blanks,
or newlines. Further, there are three special strings that
can be used with input values: Loop,
Interp, and Last
Loop: Use a set of values described by the 2 or 3
following values: FirstValue, LastValue,
Increment. When the optional Increment is
not supplied, either +1 or -1 is used.
Increment may be silently sign-corrected.
The values may be integers or floating point values.
No other values may appear on the input line. Note that
LastValue is not guaranteed to be included (see example 3).
Here are some examples:
Loop 1 10
Loop 1 10 2
Loop -0.5 pi .25
Loop 3 -10
Loop 100 80
which create 10, 5, 15, 14, and 21 values respectively.
Note that no variable may have more than 256 values.
Interp: Interpolate. This special format
indicates that n values are to be used (at equally-spaced
intervals)
between the FirstValue and LastValue. 3 other values must appear
on the input line. In this example
Interp 7.5 4 10
6 values are used: (7.5, 8, 8.5, 9, 9.5,
10). No other values may appear on the input
line. Since no variable may have more than 256 values, n
must be 254 or less.
Last: Use the result of the previous evaluation
of the expression (zero is used for the first
pass). "Last" must be a stand-alone value.
ComputeSoup provides three mechanisms to review some simple statistics
about computed (and input) values. First, when an equation is
used, statistics about the computed variable are saved in the
Store. These simple stats (count,max,min,avg,stdev)
are available by clicking
→
.
Second, maximum, minimum and median values are highlighted in
the standard output when more than two values are computed.
(When there are an even number of results, the median value is
computed.) And finally, if the Show Stats option is
enabled, a small table of statistics is displayed below the computed
results. Here is a sample (after clicking
and checking the
Show Stats box). Note that the (Min,Max,Mdn)
values are displayed independent of the status of the Show Stats
option.
ComputeSoup provides a mechanism to create user-defined functions,
and use them in subsequent computations during the same
session. Each must have 1-8 arguments and return a single
value. Each argument must be used at least once.
User-defined function names follow the same rules as variable names,
and may not take on the name of an
existing ComputeSoup function or constant. A user-defined function
can be used just like any other function (e.g., it may have
constants, variables, and other single-valued functions as arguments;
it may be used in expressions and equations and as the arguments to
other functions), except that user-defined functions may not nest.
That is, a user-defined function may not be used
as an argument to a user-defined function. The special
format for creating a user-defined function is illustrated below:
cos2(a,b) ::= pi*(a*cos(2*a+b) -
b*cos(a-2*b));
The cos2(a,b) is the user function prototype, with two dummy
arguments (a and b), followed by ::= (two colons
and an equal sign), followed by the function definition
pi*(a*cos(2*a+b) - b*cos(a-2*b)) and an optional semicolon
(;). The function definition must use each of the dummy
arguments at least once (no other variables are allowed), and may
also use numbers, ComputeSoup constants, functions, and any of the
ComputeSoup mathematical operations (e.g., +, –, *,
etc). As with any other entry in the [Expr] box,
whitespace is ignored and entries are case-insensitive.
Note that user functions are stored as complete parse-trees (not
symbolically). This means that it is not necessary
to encase the definition in parentheses. That is,
given a user function abc:
abc(x,y) ::= x - y
the expression r * abc(x,y) will always be evaluated
as r*(x-y), not as (r*x) - y.
A review of the current user functions and some information about each
is available in the Store: click
→
.
User functions can not be overwritten, but may be deleted: click
→
.
Here is some sample output from an equation which uses
both user functions mentioned above. Note that in this sample,
three of the four user function dummy arguments are populated by
constants and one is a variable (p). In fact, any dummy
argument in a user function may be replaced with a constant,
a simple variable, or an expression.
zippo = abc(6.733, pi)*cos2(p, 1.53)
One variable p with
values of "Loop 1.103, 1.83, 0.084" was used. Note that when
user-defined functions are employed in an expression, they are
always listed in green.
ComputeSoup provides two functions to perform approximate integrations
{Integrate() and Quadrature()}. They use the
same numerical approximations to integrations, and produce the
same results. The only difference is that Quadrature()
always shows the convergence to the approximate solution, while
Integrate only displays convergence data when convergence has
not been achieved. Quadrature() is recommended.
Here is the definition:
Integrate( a, b, expr ): a∫ b{expr(x)} dx. Approximate result of integrating the expression (expr) from a to b. A and b are the lower and upper bounds of the (dummy) variable in expr, and must be constants with (a ≠ b). The expression expr must have exactly one variable, must be single-valued, and may be a single user-defined function or an expression with no user-defined functions. The expression expr must be continuous over the specified range, and may include any single-valued function except Rand() and IRand(). Unpredictable results may occur when expr is not continuous or is otherwise ill-behaved.
Here are a sample of each:
ComputeSoup checks input expressions for validity, and puts out a
message when it detects an anomaly (e.g., a non-standard character,
a parsing problem, mismatched parentheses, unrecognized function names,
et cetera). Here are some samples:
Sin( radians ): Sine of the angle radians (radians). Same as Sinr()
Yes
bb = sqrtt(time+0.2*penalty)
input error -- "sqrtt" at character 6 is not a recognized Function
1 Diagnostic: see input equation below
bb = sqrtt(time+0.2*penalty); .....^
When a computational error is encountered, ComputeSoup highlights
the error and attempts to complete the other data sets.
No statistics are compiled when an error is encountered,
and data is not transferred into the Store.
Here is a sample.
seabiscuit = sqrt(x-y)/(y-x)
Setting x = 3, 5, 9 and y = 1, 2, 5, 8 generates
these results:
seabiscuit
x
y
------------
---
---
1)
-0.7071068
3
1
2)
-1
3
2
NSqr
3)
???
3
5
NSqr
4)
???
3
8
5)
-0.5
5
1
6)
-0.5773503
5
2
ZDiv
7)
???
5
5
NSqr
8)
???
5
8
9)
-0.3535534
9
1
10)
-0.3779645
9
2
11)
-0.5
9
5
12)
-1
9
8
4 runtime errors:
1 * ZDiv - Division by zero 3 * NSqr - Square Root of a negative number
ComputeSoup provides a variety of special purpose functions which
perform very specific computations (e.g., exploring Mortgage payoff
strategies, computing calories burned during a workout, computing
Body Mass Index (BMI), finding the day of the week of any date, finding
your target workout heartrate, integrating, exercising Ohm's Law,
counting the number of 1-bits in a word, solving quadratic,
cubic, and quartic equations, ...).
Here is a summary of a few of these functions:
ComputeSoup – A few of the Special Purpose Functions
Function
Args
Results
Prototype/Description
Expr Use?
Base
1
3
Base( int ):
Display the integer argument int in octal,
hex and binary
No
BitCount
1
1
BitCount( int ):
Return the number of 1 bits in the 32-bit integer
argument int. Same as PopCount()
Yes
Bmi
2
1
Bmi( weight, height ):
Body Mass Index – a measure of weight for height
in adults. As BMI increases, risk for many
weight-related diseases increases. Weight
is weight (lbs), height is height (ins).
Approx results: (<18.5 Underweight), (18.5–25
Normal), (25–30 Overweight), (>30 Obese)
Yes
Calories
5
text
Calories( activity, weight, dist,
min, sec ): Approximate calories consumed by
various activities. Arguments as in the table
below. For example: "Calories( running, 165, 3.25, 25,
20 )" yields "408 calories -- Running (165lbs, 3.25mi in
25:20 => 7:48/mi = 7.70 mph)". See also
Fitness(), HeartRate(), Karvonen(), Points(), Bmi()
Cubic( a, b, c, d ):
The roots to the 3rd order equation: ax³ + bx²
+ cx + d = 0,
where (a ≠ 0)
No
DayOfWeek
3
text
DayOfWeek( year, month, day
): Print day-of-week for input date:
year > 1752, month (1-12) for
(Jan-Dec), and day (1-x),
(28 ≤ x=f(month,year) ≤ 31)
No
Factor
1
mult
Factor( int ): List
all the prime values which divide evenly (with no remainder)
into integer int. Max value for
int is (231–1) =
2,147,483,647
No
Function
Args
Results
Prototype/Description
Expr Use?
HeartRate
2
text
HeartRate( age, restingPulse
): Display maximum and various other workout-related
target heart rates: age is age (integer,
(10–100)), and restingPulse is resting
heart rate (integer, (35–90)). Same as
Karvonen().
No
Integrate
3
text
Integrate( a, b, expr ):
a∫
b{expr(x)} dx. Approximate
result of integrating the expression (expr) from
a to b. A and
b are the lower and upper bounds of the (dummy)
variable in expr, and must be constants with
(a ≠ b). The expression
expr must have exactly one variable, must be
single-valued, and may be a single user-defined function or an
expression with no user-defined functions. The
expression expr must be continuous over the
specified range, and may include any single-valued function
except Rand() and IRand(). Unpredictable results may
occur when expr is not continuous or is
otherwise ill-behaved. Same as Quadrature(), except
Quadrature() always shows convergence of the approximate
solution. Quadrature() is recommended.
No
PayoffExtra2
4
table
PayoffExtra2( payment, rate,
balance, extra ): Show impact of extra amount
submitted with each future mortgage payment when the loan is
partly paid off: payment
=
Monthly payment (principal + interest only: no escrow) rate = Annual interest
rate (percent - e.g., 6.75)
balance
= Current balance (principal) extra =
Extra amount with each payment Same as Payoff2().
See also Refinance(),
Mortgage(), and the other Payoff*() functions.
No
RacePace
4
text
RacePace( distance, hours,
minutes, seconds ): Pace (mm:ss/mi) for race of
distance distance miles run in
hours hours, minutes minutes, and
seconds seconds. Note that
distance may be a constant or an expression,
e.g., MARATHON, TENK, FIVEK, 100/1760, 0.8*KM, METRICMILE,
HALFMARATHON, etc
No
Solver
many
mult
Solver( nEqns, x1, x2, ...
): Solve nEqns equations in
nEqns unknowns (1 ≤
nEqns ≤ 8). There are
(nEqns*(nEqns+1)) more arguments,
representing the equations. Solver() is the same as
Unknowns(). For example: x + 2y + 3z = 4
2x + y + 4z = 5
3x + 3y + 6z = 12 For these
equations, using Solver(3, 1,2,3,4,
2,1,4,5, 3,3,6,12) yields: x = 7,
y = 3, z = –3