ComputeSoup – Web Computational Engine

(Equation/Expression Evaluation)

CrunchJr is a powerful computational engine which is a superset of the capabilities found on this web site. It is available as a 99¢ iPhone/iPad app. It has 250+ MiniApps, 300+ Functions, and a wide variety of other handy features. For an overview, visit www.crunchjr.com.

ComputeSoup – Advanced Features

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 235 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.

( 1 User-defined function )
( 5 variables, 29 values )

(Sorting silently drops duplicates)

Ascending Descending

All Selected

List Nolist

All Selected

All Selected

Click to find descriptions of
these buttons. For example, clicking on
would lead to a report which looks like this:

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.

alpha = b*((x2+sqrt(x2))/(sin(pi*angle/exp(b))-.137))

For this equation with three values for b, three values
for x2, and one value for angle, typical results could
look like:

alpha = b*((x2+Sqrt(x2))/(Sin(PI*angle/Exp(b))−.137));

alpha

b

x2

angle

-------

---

----

-------

1)

8.1176609

1.401

1

0.6501

2)

9.139128

1.401

1.17

0.6501

Max

3)

9.5526721

1.401

1.24

0.6501

Min

4)

3.892497

1.03

1

0.6501

5)

4.3823003

1.03

1.17

0.6501

6)

4.5805987

1.03

1.24

0.6501

7)

5.5954168

1.213

1

0.6501

Mdn

8)

6.2995031

1.213

1.17

0.6501

9)

6.5845546

1.213

1.24

0.6501

Avg

StdDev

Min

Max

Median

6.460481

2.083267

3.892497

9.552672

6.299503

After completing the computation, clicking
→
yields:

the Store – Statistics

( 1 variable, 9 values )

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.

a2 = Sqrt(Abs(1+Sin(x)*Cos(y)/Sqrt(x^2+y^2)));

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:

Integrate(1.33, 1.57, x*Sin(x)^2);

~ .3416035

Quadrature(1.33, 1.57, x*Sin(x)^2);

~ .3416035

Convergence Information

Criterion: | Δ/Value | < 10-6

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:

val=(0.5/a)*(-b+-sqrt(b^2-4*a*c))

input error -- can't understand "+-" (character 18) ^

1 Diagnostic: see input equation below

val = (0.5/a)*(-b+-Sqrt(b^2-4*a*c)); .................^

abc = sin(gg,omega)*cos(gg*omega))

input error -- expression has an unmatched ")" at character 35

input error -- equation has mismatched "()"s,
2 "("s but 3 ")"s

input error -- Sin() should have 1 argument
(2 arguments at character 7)

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.

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:

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.

ComputeSoup – Overview

This web site allows users to evaluate expressions (including those
which have variables – each with one or more values),
and display the results in an easy-to-read
table. Many standard mathematical
constants and
functions are
available for use in the expressions, as well as a collection of
special purpose functions
for a variety of computational chores (for example,
calculating race pace, refinance and mortgage payoff strategies,
performing integrations, calculating the number of calories burned by
various workouts). The button (above left) allows you to get more details about
these and other capabilities, and the other buttons above (e.g.,
,
,
,
)
lead to information which may be useful in building computations.
The button presents more
detail about how to use this site effectively, the
button
brings up this page, and the button provides a mechanism for sending
comments, questions and/or requests to us.

There are several advanced features, including storing results for
later use, building user-defined functions, input shortcuts,
and integration.
Click →
for details.

The major capability is to evaluate expressions and equations
(including those that have variables) and print the results out
in a table for easy review. Below are five samples:

Sample 1) tr =
(pi-2.375)*(sqrt(x)*cos(omega-x))

Calculate values for tr for three values of x and
three values of omega. This is a two-step operation: first
enter the equation into the [Expr] box (as in the sample
below) and click .

Expr

and second, enter value(s) for the variables (as in the sample below)
and click .

x

omega

This will yield the results shown below:

tr = (PI-2.375)*(Sqrt(x)*Cos(omega-x));

tr

x

omega

------

---

---------

Max

1)

1.6864589

5

5.18

2)

-0.9853364

5

9.1

3)

1.534163

5

17.104

4)

-0.500223

7

5.18

5)

-1.0239357

7

9.1

Min

6)

-1.5780752

7

17.104

Mdn

7)

0.2603652

10

5.18

8)

1.5068937

10

9.1

9)

1.6523817

10

17.104

This sample illustrates the use of variables (x and
omega), uses an equation (an equation is a result variable
(tr), followed by "=" and an expression). The
nine result values of tr are automatically saved in the
Store. If you use tr in a subsequent computation during
this session, those nine values will automatically be loaded
(although you can edit or override them). One constant (PI)
and two functions – Sqrt() and Cos() – are also
used. The maximum, minimum and median value of the results are
flagged. Further, note that whitespace is ignored in the
[Expr] box, but that whitespace is important for entering
variable values. Values are separated by any combination of
one or more blanks and commas.

Sample 2) Using Race Functions

How long will it take to run a marathon at a steady
pace of 7:15 per mile?

The Racetime() function has three arguments (distance, minutes,
and seconds). It shows the time to cover the distance at the input
pace. Enter the information into the [Expr] box and
click .

Expr

which yields

Racetime(MARATHON, 7, 15);

The Marathon: 26.21875 mi at 7:15/mi (8.28 mph)
=> 3:10:05

In this sample, marathon is a constant. The
Racepace() function performs the reverse operation –
it takes 4 arguments (distance, hours, minutes, seconds) and reports
overall pace for a given distance and time. In this sample,
the variable xmin is used to check out the paces for various
overall times.

Expr

Enter value(s) for xmin and click .

xmin

which yields

Dist (mi)

Time

Pace

The Marathon:

26.21875

3:00:00

6:52/mi

(8.74 mph)

The Marathon:

26.21875

3:10:00

7:15/mi

(8.28 mph)

The Marathon:

26.21875

3:20:00

7:38/mi

(7.87 mph)

The Marathon:

26.21875

3:30:00

8:01/mi

(7.49 mph)

The Marathon:

26.21875

3:40:00

8:23/mi

(7.15 mph)

The Marathon:

26.21875

3:50:00

8:46/mi

(6.84 mph)

Sample 3) Calories burned

How many calories do you burn in a 50 minute, 13½
mile bike ride if you weigh 165 pounds?

You can use the Calories() function. Enter
calories() in the [Expr] box and click
to see the arguments.
This yields the following table, which shows that the Calories()
function can be used with 40 different activities (for this sample, we
choose cycling):

Calories( CYCLING, 165, 13.5, 50, 0 );

In this sample, cycling is a constant. Check the
Prototype/Description table above for other activities which are
supported by Calories(), for example, running, swimming, tennis,
walking, aerobics, ....

Here are two more Calories() samples (running and walking).

Expr

which yields

Calories( RUNNING, 175, 3, 22, 40 );

402 calories -- Running (175 lbs, 3mi in 22:40 => 7:33/mi =
7.94 mph)

Expr

which yields

Calories( WALKING, 140, 3.8, 63, 0 );

Sample 4) Paying off a loan early

Consider a mortgage at 6.55%, with payment of $1,331.76 per month, and
an outstanding balance of $204,236.70 – what will be the
impact of paying an extra $200 each month (assuming no prepayment
penalties)? What about other amounts?

You can use the Payoff2() function. Enter
payoff2() in the [Expr] box and click
to see the arguments.
This yields

This computation is based only on principal andinterest, and assumes no prepayment penalty.Escrow (taxes + insurance) is not part of the computation.

This shows a set of results for paying an extra $200.00 with each
monthy payment. The impacts are an overall savings
of $77,785 (17.5%) and a reduction of almost eight years of
payments.

To investigate the impact of other extra amounts per month, use various
values for the extra variable. Enter:

Expr

Note the variable add – picking a set of values for
add allows us to do a simple parameter study. That is,
we can easily see the results of various extra payment amounts.
Now click ,
then enter the additional amount(s) to pay for each month
(values for add) and click to see the impact

This computation is based only on principal andinterest, and assumes no prepayment penalty.Escrow (taxes + insurance) is not part of the computation.

Note that the Payoff() function is similar to
Payoff2(), except that Payoff() works with a loan
starting at the beginning instead of during the payoff lifetime.
To see other financial functions,
go to the top of this page and click
→
, or click
→
. The
financial function Refinance() is described below.

Sample 5) Refinancing a loan

Consider a mortgage at 7.375%, with payment of $1,885.66 per month and
outstanding balance of $210,420 – what will be the implications of
refinancing at 5.125% with a $2,750 refinance charge and taking out an
additional $5,000 equity loan?

You can use the Refinance() function. Enter
refinance() in the [Expr] box and click
to see the arguments.
This yields

This computation is based only on principal and
interest, and assumes no prepayment penalty.
Escrow (taxes + insurance) is not part of the computation.

"Breakeven" is defined as the time (months) from the new
mortgage til the current and new balances are the same. This
computation is more representative than the simpler
(delta dollars)/(delta payment) method, and when the new interest rate
is lower than the old rate, will result in a quicker breakeven.

Note that the $5,000.00 equity "loan" with the
refinance will end up costing $7,174.80 (that is, $2,174.80 in
interest)

The rightmost column
represents the "what-if" computation of getting the new loan
(5.125%), but continuing to pay it off with the old payment
($1,885.66)

Click Advanced Features to review
some of the more advanced ways to use ComputeSoup (also available via
→
).