*MathStar
A smarter way to work with Numbers*

Document Version 1.0

©1994-1997, Sine of the Times. All rights reserved.

Welcome to **MathStar: a smarter way to work with numbers.**

The Newton is an *amazing* technology. MathStar uses and extends the power of your Newton.
It easily defines a new standard for calculators through a remarkable
interface, strong functionality, and superior expandibilility.
MathStar is stacked with innovative features that will help you
work better, faster, and easier.

Welcome to the *Strength of Numbers*.

** MathStar's** most innovative abilties are to help you work with, and organize
your calculations & results.

- all
**calculations and results are***saved* - calculations and results can be
**organized into***work sheets* of*combinations***several types of calculations**and**results**are permitted- calculations and results can be assigned
*names* - many calculations and results record the source of their answers
- you can
any calculation or result*duplicate, or delete*

MathStar allows you to organize your mathematics by ** work sheets**. Imagine separate sheets of paper, on which you perform various
kinds of computations. You may have a sheet for doing general
calculations, another for your physics class, one for tracking
your bills, and one for keeping important results.

Work sheets in MathStar work the same way. They allow you to organize* groups* of calculations & results. A work sheet can contain any number
& combination of equations, solutions, graphs, models, arrays,
tools, and more, in the **same** sheet, and in the order you have created them.

You can move up and down through the calculations in work sheets, by simply using the Newton up and down arrow scroll-keys.

In addition, you can create new work sheets, delete them, or rename them, using the action button at the lower right of the screen.

The work sheet is indicated in the upper right corner of the screen. Tapping on the work sheet brings up a list of other work sheets which you can switch to.

When you switch to a different work sheet, your calculations in
that sheet automatically appear at the last location you were
in the sheet.

In addition work sheets also provide additional functionality.
MathStar remembers all solutions, tools, arrays; and makes these
available in other calculations. These solutions, tools, etc.
are taken* only *from your *current* work sheet. They are available wherever you see the following
buttons:

These buttons will become very important the more you become familiar with MathStar.

The **GLOBAL** work sheet is a special sheet, since results, tools, etc., which
reside in this sheet, are available to *all* the work sheets.

The default work sheets which come with MathStar are:

- Constants (common numeric constants)
- Examples (examples of most slips)
- Financial (example of specialized tools)
- GLOBAL
- Work Sheet (blank work sheet)
- Models (example model)
- Function Tools (more examples of tools)

NOTE: You can modify or remove any work sheet except **Examples** and **GLOBAL** (these sheets *must* remain intact, but you can change what slips are in them).

When you first run MathStar, the *Examples *work sheet is loaded for you. This sheet shows you several examples
of calculations that can be performed using the package. In
addition, on a reset of your Newton, MathStar always defaults
to the Examples work sheet.

As you enter more calculations in a sheet, they will start to scroll off the viewable area of the screen. MathStar provides several methods for you to navigate within a work sheet.

The first and obvious method is to use the arrow scroll-keys provided on your Newton. These keys will move sheets up and down.

The second, more powerful method is to use the overview feature. The overview feature lists all calculations in the sheet in compact single lines. To see the overview for a sheet, press the Overview button on your Newton.

For example, the overview for the Examples work sheet looks like:

The overview tells you the **name **of the calculation, what **type** it is, the **date** of creation, and for most slips, what its **contents** are.

To **jump** to a calculation, simply tap on the row of any calculation. MathStar
will close the overview, and show you that calculation.

Work Sheets also have a set of preferences associated with them.
Most preferences are located in the preferences screen, accessible
by choosing **Prefs** from the info button in the lower left of the screen.

The preference screen looks like:

*<picture of preferences screen>*

The first set of buttons is the angle mode. You can change the default angle mode of Radians of the work sheet by selecting a new mode here.

The second item in the screen is the numeric format picker. The default format for solutions displayed in the work
sheet is in **Normal **representation. You can change the default setting to **Science** or **Fixed** representation, and set the degree of accuracy, using the accuracy-guage
that appears.

The third item allows you to specify the font size used in displaying your solutions. By default, the font size is 18 point.

The new modes apply only to *new* calculations, and do *not* affect old calculations, unless you recalculate them yourself.

If** AutoScroll **is on, MathWorks **jumps** automatically to new calculations and results that appear in
the work sheet. This is useful for example, if you are working
with a previous calculation further up in the sheet, and produce
a new result that you want to see immediately.

The calculations that make up a Work Sheet, are called **Math Slips**.

**Math Slips **are like the stationery in your notepad, or like a card in the
Newton Names. Similar to those programs, you can **create** a different slip for *every* calculation you perform, or you can **modify** an existing Slip. In addition, you can **delete** a Slip. MathStar also *automatically* creates new slips for the *results* of your calculations.

There are two different types of Math Slips:

- Those you create by choosing by using the "New" button
- Those created by MathStar to display results of a calculation

Equation | use to enter equations (eg. 1+2) |

Tool | use to create user functions |

Graph Setup | use to enter functions and range values for graphs |

Model Setup | for setting up the vectors and faces of a model |

Arrays | for 1,2, or 3 dimensional arrays |

Conversion | for converting results to different units |

Solutions | numeric or text results of calculations |

Graphs | displays a 2D graph |

Models | displays a 3D model |

Distribution | displays a bar chart distribution |

The calculation slips, and result slips are combined together to form work sheets, in the order the calculations were performed.

For example, you may choose to calculate 1+2, so you would create an Equation slip, to enter the equation. After you have entered the equation, you will then solve the equation. The answer is displayed and stored in a Solutions slip.

Your work sheet would look something like this:

Let's say now you want to do a graph. You would create a Graph Setup slip, in which you would enter the function (or set of points) you want to graph, and then you would ask MathWorks to graph it for you. This result: a Graph.

As you can see from the example figure on the first page, you
can **combine several types** of different calculations together in the *same* work sheet.

Creating a new slip is easy! Use the **New** button located at the lower left of the screen, and choose the
type of Math Slip you want to create.

New slips are added to the end of the work sheet. If **AutoScroll** is on, MathStar will automatically take you to the new slip.

Each slip in MathStar has a slip control bar at the top of the slip. On this slip is the name of the slip, the date of creation, a fast deletion button (the scissors), a filing button (the folder), and an action button (the envelope). Sometimes a source button is also on the slip shown as a ~ button in the center of the slip.

Every slip in any work sheet can be **named**. For example, the figure below shows an **Equation slip named as My_Equation**, and a **Solution slip named as trig_answer.**

The default name for the slip appears in the left corner of every slip control bar, as shown in the figure below:

Tapping on the current name, brings up the name editor.

You can change the name of the slip to anything you like. MathStar will automatically insert underscore '_' characters for names with spaces in them when needed.

Slip naming in MathStar has several purposes:

- naming allows you to
your calculations and results, helping you discern between them*identify* - naming allows MathStar to provide some types of results for use in other calculations, as described in the next section

As mentioned earlier, MathStar remembers solutions, tools, and
arrays, and allows you to use these again in new calculations.
These values are stored in "**Memory**" pop-ups.

Finding and using these solutions, tools, and arrays, is easy. The memories, if available, are always located in the lower right of the slip you are using.

The solutions pop-up lets you choose solutions solved from other
equations.

The tools pop-up shows you tools that have been created and are
available.

The array pop-up shows you the arrays that are available for use.

The memories are setup as follows:

Choosing a value from a pop-up inserts the value in your equation
slip, tool, graph, or other slip wherever the cursor is. Depending
on the slip you are inserting into, MathStar will also automatically
setup the ** calling** requirements to use the values. See the section on calling requirements
for advanced technical information.

- Memory Pop-ups first get their solutions, tools, and arrays from
the
**GLOBAL**work sheet. - They then get local solutions, tools, and arrays from the
work sheet you are in.*current*

The solutions, tools, and arrays that appear in the pop-up buttons
are *dynamic*. This means, the moment you add a new result, tool, or array,
it will appear in of the memories depending on what it is.

Similarily, if you *delete* a solution, tool, or array, it will be removed from it's respective
memory.

Several slips such as solutions and graphs, show the source of their results. For example, the following solution slip shows the calculation source (which would have been entered in an equation slip).

*<picture of solution slip with the result source>*

You can examine the solution sources, by pressing the **~**key on the header bar of the slip. *Only* those slips which have the ability to show their source will
have the ~ in the header.

Slips can be filed in different sheets.

To file a slip in another sheet, press the folder button on the
Slip Control bar, and choose a destination work sheet. The
slip's time stamp is updated and added to the end of the work
sheet.

TIP: If you want to move a slip to the end in the same work sheet, just file it to the same work sheet.

Each slip has an action button on the right side of the slip control bar. The action button allows you to duplicate or delete the slip.

You can alternatively, press the "scissors" button shown on the slip bar below, to quickly delete a slip.

**Warning: deletion of a slip is permanent, and cannot be reversed
with undo.**

MathStar provides you with several tools to enter numbers, expressions, functions, etc.

The first set of important tools are the keyboards, as shown below. You can access the keyboards under the keyboard icon next to the Close button, and then selecting a keyboard.

The numeric keypad is special, in that it has been written specifically for MathStar, and provides you with features not found on the standard Newton numeric keypad. For example, all decimal values must be expressed as 0.value, not just .value. The MathStar keypad is smart enough to know when to insert a 0 in front of your decimal value. Whenever you are entering numbers into any field of MathStar, try to use the numeric keypad.

To assist you in using the correct keyboard, If you double tap in a equation slip, MathStar's numeric keypad is opened, not the Newton's default.

The function pickers located next to the Keyboard icon, pop-up
a list of functions. Choosing a function inserts it at the *current* caret position in *any* display.

The Equation slip is the calculation slip you will likely be using the most. It is used to enter equations that you want to solve.The first slip in the figure below is an equation slip with an example equation.

The result of an Equation Slip is a Solution Slip, shown in the next section.

- Choose Equation under the
**New**button

The buttons on the Equation slip are:

Button | Purpose |
---|---|

Solve | Solves the equation in the display, and produces a Solution Slip as a result |

C | Clear the display (not undoable) |

Solns | "Remember Me" Solutions picker |

Tools | "Remember Me" Tools picker |

Arrays | "Remember Me" Arrays picker |

The Solution slip displays results computed by MathStar. You cannot explicitly create a solution slip, MathStar has to do it for you.

Pressing Solve in an equation slip, for example, creates a Solution slip.

Solution slips do have some special abilities. You can:

- Change the
**accuracy**and**format**of numbers displayed by changing the preferences under the**Info**button - Change the
**default font size**of the displayed result by changing the preferences under the**Info**button - Copy the result to the clipboard, by tapping once on the result to hilite it, and then dragging it off the left edge of the screen
- Display the source of the result by pressing the
**~**button

MathStar provides a development environment for writing custom programs for use with the calculator. You can define as many as tools as you like, both globally or locally for your work sheets.

There are several example tools included with MathStar in the Function Tools and Financial work sheets - including some complex ones.

The toolbox uses NewtonScript (NS) as the programming language.
Knowledge of in-depth NS is not necessary (though familiarity
with any computer language would be helpful). The tool slip provides
pop-up lists of many NS functions and commands that can be used
in your programs. Books such as *Programming for the Newton* can help you in developing highly complex functions for MathStar.
You can also download a complete reference to NS from Newton,
Inc.'s dev. site.

- To create a tool, simply select tool under the "New" button

Tools normally take parameters, perform calculations on them, and return a calculated value. MathStar sets up much of this required syntax for you. Once defined, tools are available for use in MathStar slips through the Tools "Remember Me" pop-up.

Tools need to be called as follows:

**tool:<function>(parameters)**

**examples**

**tool:mycalc(5,6,7);**

**tool:test();**

The "**tool:**" in front of the "**function**" signifies that MathStar is to look up the tool and send the
parameters in parantheses to the **function**. These words are automatically inserted when the tool is chosen
from the tool memory.

The tool slip buttons are:

**Code Box Function pop-ups**

Directly underneath the code box on the left are function pop-ups. These pop-ups provide common NS functions and commands you can use in your program. These are by far, not a complete list - but only intended as a reference. For a detailed list of the included NS functions, see the Chapter on Advanced Technical Information.

**Code Box Common keys**

Directly underneath the code box on the right are also common keys. These keys insert common characters used in NS syntax. They are provided to ease the entering of code.

**Tools / Functions**

The syntax for a tool looks like:

func( parameter 1, parameter 2, ... , parameter n )

begin

... your program

return some result...

end

Tools can take any number of parameters or none at all. Simply
enter the names of the parameters in the parenthesis after "func".
The parameters created become *local* variables in your function, which you can use or modify within
the tool.

Usually tools return some kind of result to MathStar.

You can return both numeric and string values as valid results. MathStar will automatically recognize and format your results.

When you successfully compile a new tool, MathStar automatically
adds it to the **Tools Memory**. In doing so, MathStar also adds the required calling syntax
for the tools. Thus if you choose the tool from the Tool Memory
- all of the calling syntax is done for you.

*You must pass the same number of parameters as defined in the function,*otherwise an exception error will be thrown.- The calling convention "tool:<function>(paramaters)" applies in all slips.
- There are several example tools included with MathStar - we recommend you review these before developing any of your own functions

The array slip is used for:

- Storing sets of numbers for statistics & memory operations
- Creating user-defined 2D graphs of x & y values
- Specifying vertices for 3D models

Depending on what you need, you can create either a 1, 2, or 3 dimension array.

For statistics and memory operations, and the distribution slip,
a 1 dimension array is needed.

For the graphing slip, a 2 dimension array (x,y values) is required

For models, a 3 dimension array (x,y,z values) is required

- To create an array, simply choose the appropriate size under the New button.

Each row is identified by an index value in the first column.

To select a row, tap on the index value.

A default array only comes with one row. You can add new rows by pressing the:

- Add Button - this adds a new row to end of the array
- Insert button - allows you to add a new row
*before*or*after*the currently selected row

To remove a row, first Select a Row, by pressing on the index value of the row (the number in the first column), and then press the Remove button. The row will be permanently removed.

To change the cell value, simply press on the value you want to
change, and enter a new number in the editor. You can change
cell values quickly, by just tapping on the next cell to change.
The current cell being editted will be saved, and the next selected
cell value will be displayed.

You can graph functions of x, or tools of function x, or arrays
of 2 or more dimensions.

Graphing supports functions of x only (ie. f(x)). Y is f(x).

The Graph slip has several features:

- X min, X max specify the minimum and maximum values of the X - Axis respectively.
- Y min, Y max specify the minimum and maximum values of the Y - Axis respectively. These values can be over-ridden by MathStar if Auto Y is selected.
- X Step specifies the increment size of the values of X used in evaluating the function entered.
- Mark X specifies the X Marker increments
- Mark Y specifies the Y Marker Increments
- Point Size specifies the dot size of the points plotted
- Connect points cause the Graph to join the points of the plotted function
- Auto Y causes automatic calculation of the Y min and Y max range values
- X Axis turns on the X-Axis and X Markers
- Y Axis turns on the Y-Axis and Y Markers

There are built-in limits to the size of graphs that you can plot - primarily so that MathStar does not run out of system heap space. For example if you try to plot the function 1/x with Auto Y on, you would get a huge Y-Axis range- and the Newton would simply run out of heap space. To help you avoid these kinds of problems, MathStar detects large ranges among other problems to avoid running out of heap space.

The Graph slip is produced by a Graph Setup slip.

This slip automatically re-sizes itself depending on the size and orientation of the screen. So depending on the orientation, a graph may appear slightly different. (If there is ever a larger size Newton, you'll get a larger graph!)

To use the point and report cursor, simply tap on a point on the graph. The point and report view will appear displaying the actual x,y location of the point selected.

MathStar allows you to create virtual 3D models that you can rotate real-time on screen. Setting up a model, is relatively easy if you have the model prepared before.

We suggest you look at the **Models** Sheet in MathStar while you read this section.

The Model Setup slip contains two inputs:

**vertices**- the vertices of a model is a Set of x,y,z coordinates in a 3d space composed of x,y,z regions. Each vertex is assigned a numerical value from 1 to n number of points. You can either specify a**Memory Array**or create your own array of points.**faces**- the faces of the models is a Set of connected points specified in the vertices. When you specify a set of faces, MathStar connects the specified points and creates translucent polygons out of them.

The difficulties arising in creating a model are more about drawing
the object on paper and assigning appropriate co-ordinate points,
than getting MathStar to model it.

[

[x1, y1, z1], // Vertex Array 1

[x2, y2, z2], // Vertex Array 2

.

.

.

[xN,yN,zN] // Vertex Array N

]

Each **Vertex** a 3 element array of x,y,z. Each 3 element Vertex is part of
the **Vertices Sets**. You **must** specify 3 vertices for each vertex.

You can use the built-in Array slips to create a 3 element Vertices Set by selecting New: 3D array. Additionally you can specify a tool as well, as long as the tool returns an array.

[

[Vertex a, Vertex b, Vertex c, ... , Vertex n] // Face Array
1

.

.

.

[Vertex a, ..., Vertex n] // Face Array N

]

Faces are harder to describe than vertices. The elements in a Faces Set specify the Vertices to connect into a polygon. Each Face array can specify 1 or more vertices to connect into a shape.

Unlike the Vertices Array specification, each **Face Array** in the **Faces Set** can have a different number of elements. Unfortunately, because
of this feature, there is no easy way to create a Faces Set using
the array slips. Thus you need to enter your faces directly into
the Model Setup Slip as shown in the figure.

Specifying [ ] indicates to MathStar that there is no Faces Set
- and if you try to generate a model, *nothing* will appear in the model. You are required to enter a Vertices
Set however.

Model Slips are created by Model Setup Slips.

The model is a virtual 3d, auto-scaling, non-perspective view of a static object. At this time, MathStar only permits you to do 3D rotations on the object. Each face of the model is shaded but is transparent. If you are using a speedy Newton (such as an MP 2000), the 3D rotation is real-time. To rotate an object, simply tap your pen anywhere in the slip and drag it.

Moving your stylus in a North or South direction rotates the object
along the X Axis.

Moving your stylus in a East or West direction rotates the object
along the Y Axis.

The convert slip allows you to convert a numeric value from one unit to another unit. There are approximately over 300 conversions built into MathStar.

To convert a value:

- enter the value in the
**Value to Convert**field - select the
**Type**of unit - (eg. Velocity, Length, Volume, etc) - choose the current unit in the
**From**list - choose the unit to convert to in the
**To**list

Your final answer appears in the **Converted Value** field. You can create a new solution slip with your results
by pressing the **Post** or **Solve** in the lower right of the slip.

The distribution slip creates a frequency distribution or histogram of a set of data contained within a single dimensional array. This is useful for visually examing the distribution of the data being plotted as well as the relationship of the mean to the complete data set.

To plot a frequency distribution:

1. Select 'New' and '1D Array'. Name the array if you wish.

2. Enter the data to be plotted in the created array.

3. Select 'New' and 'Math' to create a new math slip.

4. Select from the Statistics Menu - ':distribution( 1D array )'.

5. The math slip will now contain, ":distribution(".

5. Select the array to be plotted from the 'Array' popup button and tap 'Solve'. The displayed plot shows the data range, mean and frequency distribution.

5 Statistics Functions

Because of the ability to create an endless number of arrays,
you have an unlimited number of statistics registers!

There are several statistics functions for use in MathStar, and
you can also write your own.

The built-in functions all take a minimum array of 1 dimension with N elements. You can access the functions under the E picker next to the keyboard tools.

If you use the built-in array tool, you can specify the name of
the array directly in the function. However, if you wish to maually
enter the array into each function (not recommended), you must
follow the array specification in Section 7.4.

**xAverage**- returns the cummulative Average of the array**xSDPop**- returns the Standard Deviation of the population**xSDSMP**- returns the Standard Deviation of the sample**xSum**- returns the cummulative addition of the array**xSumSquares**- returns the cummulative addition of the square of each value in the array**xNum**- returns the number of entries in the array

For example, doing xAverage on the example_array in the Examples
sheet would appear as:

:xAverage(list.example_array)

in the Equation Sheet.

MathStar offers the standard set of functions found on most calculators. In additon, several special & financial functions are provided under the E pop-up.

- Linear Regression
- Quadratic Equation
- Polar <--> Rectangular
- Decimal <--> Hexadecimal
- Integer to Time

When we wrote MathStar we did away with the traditional fixed
number of memory registers approach entirely. What was developed
was a dynamically sizing, and virtually unlimited memory system
that intelligently categorizes solutions, arrays, or tools, as
*memories .*

The "Memory" pop-ups are managed by MathStar for the user when
using standard slips. However, it is possible to modify the contents
of the "Memory" pop-ups *directly* from a tool.

For example, we can modify the contents of the **Solns Memory **pop-up:

**Create a tool to add to the pop-up**

Make a tool named test

func()

begin

soln.direct:=5;

end;**Run the tool**

tool:test()**Check the pop-up**

Direct should appear in the**Solns****Memory**pop-up! You can now use it in your equations**Note**

Because you are modifying the Memories directly, you will need to run your tool each time you switch folders or re-enter MathStar. MathStar creates memories from slips that exist in a work sheet, but does not remember memories from tools on a permanent basis.

The other memories are **list** (for Arrays), and **tool** (for tools). You can modify these pop-ups too. If you need
help on doing this, contact us.

- * multiply
- / divide
- div integer division
- fmod modulus (remainder)
- + addition
- - subtraction

To use the built-in NewtonScript functions, simply use them in your equations. The following list briefly details these functions. All functions can use real or integer values unless specified. All NS trignometric functions work in Radians only. Use the MathStar trignometric functions to work in Degrees or Gradians as well.

- Band(a,b) Integer Bitwise and (a and b). Example: 1 and 0 = 0.
- Bor(a,b) Integer Bitwise or (a or b). Example: 1 or 0 = 1.
- Bxor(a,b) Integer Bitwise exclusive or (a xor b). Example: 1 or 0 = 1.
- Bnot(a) Integer Bitwise inverter (not a). Example: not 1 = 0.

- Abs(x) Returns the absolute value of any integer x. Example: abs(-2) = 2. (x-ref: Fabs)
- Acos(x) Returns the arc cosine of x in radians. (x-ref: Cos)
- Acosh(x) Returns the hyperbolic arc cosine of x in radians. (x-ref: Cosh)
- Annuity(r, p) Calculates the present value factor of an annuity at a given interest rate (r) over the specified umber of periods (p).
- Asin(x) Returns the arc sine of x in radians. (x-ref: Sin)
- Asinh(x) Returns the hyperbolic arc sine of x in radians. (x-ref: Sinh)
- Atan(x) Returns the arc tangent of x in radians. (x-ref: Tan)
- Atan2(x,y) Returns the arc tangent of x/y with result being between -x and x, to determine the quadrant of the calculated tangent. Both x and y are in radians.
- Atanh(x) Returns the hyperbolic arc tangent of x in radians. (x-ref: Tanh)
- Ceiling(x) Returns the smallest integer not less than the specified real number (i.e. rounds up the real number to an integer).: ceiling (2.10) = 3. (x-ref: Floor)
- Cos(x) Returns the cosine of x in radians. (x-ref: Acos)
- Cosh(x) Returns the hyperbolic cosine of x in radians. (x-ref: Acosh)
- Erf(x) Returns the error function of x. (x-ref: Erfc)
- Erfc(x) Returns the complimentary error function of x. (x-ref: Erf)
- Exp(x) Returns e (2.718282) raised to the x th power. (x-ref: Expm1, Log, Logb,Log1p, Log10)
- Expm1(x) Returns the base e exponential value of x-1.: exp(x) - 1. (x-ref: Exp,Log, Logb, Log1p, Log10)
- Fabs(x) Returns the floating point absolute value of x.: Fabs(-2.2) = 2.2. (x-ref:Abs)
- FDim(x, y) Returns the positive difference between x and y. Note, x > y returns x-y, however, x <= y returns 0.
- Floor(x) Returns the largest integer not greater than the specified real number (i.e. rounds down the real number to an integer).: floor (2.80) = 2. (x-ref: Ceiling)
- Fmax(x, y) Returns the maximum of x and y. (x-ref: Fmin)
- Fmin(x, y) Returns the minimum of x and y. (x-ref: Fmax)
- Fmod(x) Returns the floating point modulus of x and y.: m = fmod (x, y) and q = trunc (x / y), then q * y + m = x. (x-ref: mod)
- Log(x) Returns the natural logarithm of x. (x-ref: Exp, Expm1, Logb, Log1p, Log10)
- Logb(x) Returns the binary exponent of x as a signed integral value. (x-ref: Exp, Expm1, Log, Log1p, Log10)
- Log1p(x) Returns the base e logarithm of 1+x. (x-ref: Exp, Expm1, Log, Logb, Log10)
- Log10(x) Returns the base-10 logarithm of x. (x-ref: Exp, Expm1, Log, Logb, Log1p)
- Nearbyint(x) Returns x rounded to the nearest long integer and returns the result as a real. Example: nearbyint(100.6) returns 101. (x-ref: Rint, RintToL, Round)
- Pow(x, y) Returns the x to the power of y (i.e.. x^y). (x-ref: Scalb, Sqrt)
- Random(l, h) Returns a random integer between l and h inclusive: random (2,5) = 4.
- Remainder(x, y) Returns the remainder of x / y. (x-ref: Fmod, mod)
- Rint(x) Returns x rounded to the nearest long integer. (x-ref: Nearbyint, RintToL, Round)
- RintToL(x) Returns x rounded to the nearest integer. (x-ref: Nearbyint, Rint, Round)
- Round(x) Rounds x the nearest integer using a format similar to the Fortran anint function (i.e.. add half to the magnitude and truncate). (x-ref: Nearbyint, Rint, RintToL)
- Scalb(x, y) Returns the value x * 2^y. (x-ref: Pow)
- SignBit(x) Returns a non zero value if the sign of x is negative. (x-ref: Signum)
- Signum(x) Returns -1 if x<0, 0 if x=0, and 1 if x>0. (x-ref: SignBit)
- Sin(x) Returns the sine of x in radians. (x-ref: Asin)
- Sinh(x) Returns the hyperbolic sine of x in radians. (x-ref: Asinh)
- Sqrt(x) Returns the square root of x. (x-ref: Pow)
- Tan(x) Returns the tangent of x in radians. (x-ref: Atan, Atan2)
- Tanh(x) Returns the hyperbolic tangent of x in radians. (x-ref: Atanh)
- Trunc(x) Returns the integer portion of x. (x-ref: Round)

The **built-in Newton numeric functions only work in the US (American)
format**, ie. a decimal has to be a "." and group separators are always
",". Due to this limitation, using MathStar in another locale,
such as Germany, would normally produce problems with the calculator.

MathStar does get around this. Our solution was to *simulate* the US environment. You can use MathStar in any locale, but
you will have to use the US format for numbers.

NewtonScript provides integers and real values through the StrongARM processor.

MathStar automatically converts every number you enter into a real by ensuring there is a decimal place in the value. This is to overcome the problem of exceeding the limited integer range (see below), which instead of generating an error, produces an incorrect value. All of this is done in the background - you will never see it. It is done for the Equation, Graphing, and Model slips only. Tools and Arrays still require explicit representation of integer and real values.

Integers range from 536870911 through -536870912. When that limit is exceeded behavior is undefined. Thus you must use a Real number for values larger or smaller than the above.

Source: Newton Language Reference, Apple Computer

A real number consists of one or more digits followed by a decimal point with zero or more additional digits. You can specify scientific notation by placing the letter e (upper or lower case) directly after the last digit and following it with a negative or positive digit in the range of -308 to +308.

NewtonScript floating point real numbers are represented internally in double precision; 64 bits. They have approximately 15 decimal digits of precision.

Source: Newton Language Reference, Apple Computer

Built-in arrays (ie. 1D array, 2D array, 3D array) are specified as a set of arrays within an enclosure array.

For example a 1D array has a general structure as follows:

[

[value 1],

[value 2],

.

.

.

[value N]

]

Each value is in array of its own because, if you have a 2D array,
it would appear as:

[

[value a1, value b1],

[value a2, value b2],

.

.

.

[value aN, value bN]

]

Similarly a 3D array has a structure as follows:

[

[value a1, value b1, value c1],

[value a2, value b2, value c2],

.

.

.

[value aN, value bN, value cN]

]

Unfortunately sometimes MathStar will be unable to create a slip due to an internal error, or low heap space. In these cases, the only solution is to do exit, and remove the offending slip (see below), or do a hard reset for an out of memory error. When you re-enter MathStar, the Examples work sheet will be loaded for you. The work sheet in which the error occured will not open until you remove the damaged slip.

To permanently remove an offending slip, use the **MathStar Soup Utility **included on the PowerSet disk, to delete the slip manually. In
almost every case, it is the last slip in the work sheet which
causes the error. Deleting this slip will allow MathStar you
to use your work sheet once again.

If you have recurring problems, please contact us, and we will help you.

Copyright Information

PowerSet, MathStar, Eclipse is Copyright 1994-1997, Sine of the Times, Inc (hereafter as ?SofT?). All rights reserved worldwide. Eclipse is a trademark of SofT Corporation, registered in the USA and Canada. Apple, the Apple logo, Newton and the light bulb logo are registered trademarks of Apple Computer Inc.

SofT grants a license for the use of the included software and documentation for a single user, to be installed on a single machine. If you wish to terminate the terms of this license, destroy all copies of the above said.

__You will not copy, distribute, reverse engineer, in whole or part,
any of the included software or documentation, by any means electronic,
or otherwise. Failure to comply will result in the full use of
applicable laws.__

SofT guarantees the performance of the included software as detailed in the documentation for the lifetime of the product. SofT makes no further warranties, implied, or otherwise, written or oral.

SofT will not be held responsible by the use or inability to use the included software and documentation, for any purpose or activity. SofT provides this software on a "as is" basis. No claims or warranties are made to its suitability for any task or purpose.

Under no circumstances including but not limited to negligence, shall SofT be held liable for any incidental, special or consequential damages that result in the use or inability to use the software or related documentation. In no event shall SofT 's total liability to you exceed the amount paid for the software.

Although SofT has attempted to ensure the accuracy of results produced by the included software, SofT will not be held responsible for any erroneous results, caused by software defects known or unknown. If however, you do discover an error, please contact Sine of the Times. We will do our best to help you.

Credits

**Project Leader: Ashish Mishra**

**Primary Developer: Ashish Mishra**

**Software Engineer: Robert Lee**

**Production: Mike Jacobsen**

**Management: Rachel Jacobsen**

**Documentation: Ashish Mishra**

**Example Functions: John Sandeman, Garry Trahern**