Callie Pro iPad User Guide

Use Callie Pro when you want more than a basic calculator but still want a tool that stays direct and visual.

Callie Pro is especially useful for:

• Graphing ordinary functions such as sin(x), x^2, and 2*x - 1.
• Comparing multiple expressions on the same graph.
• Exploring parametric, polar, complex, and 3D graphs.
• Animating parameterized graphs with Temporal playback.
• Tracing points, roots, extrema, slopes, and intersections.
• Creating tables from graph expressions.
• Running symbolic-style CAS operations.
• Working with matrices, systems, eigenvalues, and row reduction.
• Running statistics summaries, confidence intervals, and hypothesis tests.
• Writing small local Python scripts for numerical work.
• Exporting graphs, data, and reports as files you can save or share.

Callie Pro does not require an account. Graph documents and calculations are local to your device. Python scripts run locally inside the app's calculator sandbox.

When you open Callie Pro, the app starts in the main calculator shell. The first screen is arranged like a calculator built around a large LCD workspace.

The upper workspace shows the current tool. The lower shell contains the large workspace navigation row, the calculator keypad, modifier keys, and special input modes.

The main workspace buttons are:

• Y=: edit graph expressions.
• GRAPH: view the graph canvas.
• TABLE: view numerical tables for the active graph.
• WINDOW: adjust graph bounds and fitting controls.
• TRACE: trace graph points and analysis results.

These are workspace navigation buttons, not calculator input keys. They take you to the major graph views.

The rest of the shell gives you calculator entry, numeric keys, operations, functions, modifiers, arrows, and text entry tools.

The calculator shell is the persistent control surface at the bottom of the app.

It has several jobs:

• Enter numbers and expressions.
• Switch workspaces.
• Toggle modifier layers.
• Navigate trace points.
• Move text cursors in text entry mode.
• Insert math functions, constants, and operators.
• Run or submit workspace actions when appropriate.

The shell is intentionally fixed. When you move from Graph to CAS, Matrix, Stats, or Python, the shell remains available and the workspace above it changes.

Primary Keys

The main numeric and operation keys handle ordinary calculator input:

• Digits 0 through 9.
• Decimal point.
• Basic operations +, -, x, and division.
• ENTER for submitting an expression or action in the current workspace.
• CLEAR for clearing the active input or workspace state.
• DEL for deleting the character before the cursor.

The exact effect of ENTER, CLEAR, and DEL depends on the active workspace. In the calculator scratch area they affect calculator expressions. In CAS they run or clear CAS input. In text workspaces they route through the focused text editor.

Modifier Keys

Callie Pro includes modifier layers so the keypad can hold more functions without becoming a full keyboard.

The most important modifiers are:

• 2nd: exposes second-layer functions and symbols.
• 3rd: exposes third-layer functions and symbols.
• LTTR: switches into letter and text entry mode.
• MATH, STAT, MATRIX, CAS, PYTHON, and CATALOG: jump to or insert related tools depending on context.

Modifier previews use the app's color language. Second-layer functions use a yellow/brass accent, while third-layer functions use a green/mint accent.

LTTR Text Entry

LTTR turns the calculator shell into a text-entry layer. Use it when you need letters, variable names, Python text, CAS expressions, or function names that are easier to type than assemble from math keys.

In LTTR mode:

• Primary keys enter letters.
• SHIFT changes letter case.
• SPC inserts a space.
• TAB inserts indentation.
• ENTER inserts a newline when the active field is a text editor.
• DEL deletes text.
• The directional pad becomes text navigation.

The LTTR second layer is for common punctuation and operators such as:

. , : ; ' " _ # ? ! + - * / = ( )

The LTTR third layer is for advanced and programming-oriented symbols such as:

[ ] { } < > <= >= == != => ->

LTTR is useful in the Python workspace, CAS, complex expressions, and any field where you want to enter names or structured text.

Directional Pad

Outside LTTR mode, the directional pad is trace-oriented. It moves through graph trace points or analysis targets when a graph is active.

In LTTR mode, the directional pad becomes text navigation:

• Left and right move the cursor by character.
• Up and down move between logical lines when possible.
• The center label changes to NAV to show that it is navigating text, not tracing a graph.

This helps keep text entry calculator-native while still giving you cursor control.

Callie Pro is organized around workspaces.

The core graph workspaces are:

• Y= for editing expressions.
• GRAPH for viewing and interacting with the graph.
• TABLE for numerical values.
• WINDOW for bounds, fit, and viewport controls.
• TRACE for point-by-point exploration.

Additional workspaces include:

• Calculator scratch.
• CAS.
• Matrix.
• Stats.
• Python.
• Catalog and constants.
• Settings and export tools.

You do not need to use every workspace. A common workflow might be:

1. Enter sin(x) in Y=.
2. Tap GRAPH.
3. Tap Fit if needed.
4. Use TRACE to inspect values.
5. Open TABLE for numerical rows.
6. Export a PDF or CSV if you want to save the result.

The graph system is the center of Callie Pro.

It supports 2D, 3D, complex, and temporal graphing. Each expression lives in the graph document and can be shown, hidden, edited, traced, tabled, analyzed, and exported.

The app includes ordinary graph types and dedicated Temporal graph types. Ordinary graph types are for static graphs. Temporal graph types are for playback over a changing parameter.

The graph canvas is designed to use the available display area while keeping controls reachable. Two-dimensional graphs fill the main canvas. Three-dimensional graphs reserve room for 3D controls and readouts so that mesh, trace, analysis, and Temporal controls remain accessible.

Starter Graph

Callie Pro opens with a starter graph so the graph workspace is not blank. You can replace those expressions immediately.

To begin from scratch:

1. Tap Y=.
2. Select an existing expression row.
3. Edit the expression.
4. Hide or delete rows you do not need.
5. Tap GRAPH to view the result.

Expression Rows

Each graph expression row has:

• A name such as Y1, R1, Z1, or another prefix depending on type.
• A visibility toggle.
• One or more expression fields.
• Domain or sample settings when relevant.
• Style and graph-type controls.

When an expression is visible, Callie Pro samples and renders it if the expression is valid for the current graph type.

Use Y= to create, edit, and organize graph expressions.

The Y= editor is where you decide what a graph means. The Graph workspace shows the result; the Y= workspace defines the math.

Common tasks:

• Add a function.
• Change a graph type.
• Hide or show an expression.
• Edit domains and sample counts.
• Select a Temporal example.
• Set 3D mesh quality.
• Adjust complex height mode.

Editing A Function

For a standard function, enter an expression in terms of x.

Examples:

sin(x)
x^2
2*x - 1
e^(-0.1*x)*sin(8*x)
sqrt(x)

Then tap GRAPH.

If an expression returns complex values in a standard real-valued graph, Callie Pro does not render invalid graph artifacts. It will indicate that the result is complex and point you toward Complex Graph mode.

Adding Another Expression

Add another row when you want to compare functions.

Example:

Y1 = sin(x)
Y2 = 0.2*x^2 - 2

Both can be visible at the same time. The graph uses separate colors and labels so you can compare them visually.

Hiding Expressions

Hide an expression when you want to keep it in the document but remove it from the current graph.

This is useful when:

• You are comparing several possible models.
• You want to isolate one graph for export.
• A heavy 3D surface is slowing down the view.
• You want to keep a formula but focus on another one.

Changing Graph Type

Graph type controls determine which fields appear.

For example:

• Function uses y = f(x).
• Parametric uses x(t) and y(t).
• Polar uses r(theta).
• Complex uses z(t).
• 3D Surface uses z = f(x, y).
• 3D Curve / Vector uses x(t), y(t), and z(t).
• Complex 3D Surface uses f(z) over the complex input plane.

When you change graph types, review the fields carefully. A formula that makes sense as a function might not make sense as a surface or complex path.

Function graphs plot a real-valued output against x.

Use Function mode for formulas like:

y = sin(x)
y = x^2
y = 2*x - 1
y = e^(-0.1*x)*sin(8*x)

Example: Line

Enter:

2*x - 1

Tap GRAPH, then use Fit if needed.

The graph should show a straight line with slope 2 and y-intercept -1.

Example: Parabola

Enter:

x^2

Use the graph view to inspect the vertex and shape. Use Trace to move along the curve and Table to inspect numeric values.

Example: Wave

Enter:

sin(x)

Use Zoom and Fit to adjust the view. Use Trace to move smoothly along sampled points.

For a faster wave:

sin(8*x)

For a damped wave:

e^(-0.1*x)*sin(8*x)

Callie Pro includes viewport safety limits so extreme zooming or non-finite values do not produce unstable graph artifacts.

Parametric graphs define x and y separately using a parameter, usually t.

Use Parametric mode when the curve is easier to describe as motion or a path.

Example:

x(t) = cos(t)
y(t) = sin(t)
t min = 0
t max = 2*pi

This creates a unit circle.

Another example:

x(t) = t*cos(t)
y(t) = t*sin(t)
t min = 0
t max = 10

This creates a spiral.

Parametric graphs are good for:

• Circles and ellipses.
• Orbits.
• Spirals.
• Projectile paths.
• Curves where x is not a single independent variable.

Polar graphs use an angle and a radius.

The typical form is:

r(theta) = ...

Examples:

2*sin(3*theta)
1 + cos(theta)
3

Polar mode is useful for:

• Rose curves.
• Limacons.
• Circles centered away from the origin.
• Angular patterns.

Use Fit if the curve appears too small or too large. Use Trace to inspect angle and position.

Complex 2D graphing plots complex values on the real-imaginary plane.

A complex number:

z = a + bi

is plotted as:

x = Re(z)
y = Im(z)

So:

• 3 + 4i plots at (3, 4).
• i plots at (0, 1).
• -1 plots at (-1, 0).
• -2 + 5i plots at (-2, 5).

Complex Point Mode

Enter a constant complex expression:

3 + 4i

Callie Pro plots a point at (3, 4).

Trace readouts include:

• z
• Re(z)
• Im(z)
• |z|
• arg(z)

For 3 + 4i, the magnitude is 5.

Complex Path Mode

Enter a complex expression in terms of t.

Example:

z(t) = e^(i*t)
t min = 0
t max = 2*pi

This plots the unit circle because:

e^(i*t) = cos(t) + i*sin(t)

Other examples:

z(t) = t*e^(i*t)

Creates an outward spiral.

z(t) = (1 + 0.1*t)*e^(i*t)

Creates a growing spiral.

z(t) = e^((-0.1 + i)*t)

Creates a decaying spiral.

z(t) = cos(t) + i*sin(t)

Creates the unit circle.

Complex shorthand is accepted in complex graph expressions. You can type forms such as:

2i
3+4i
e^(i*t)
e^(it)
5t
5z

Callie Pro handles those as complex-aware notation without changing normal real-valued graph parsing.

Optional f(z) Transform

Complex mode can also graph a complex function over a path.

Example:

z(t) = e^(i*t)
f(z) = z^2

This maps the unit circle through z^2, creating a circle traced twice over the parameter range.

This is not full complex-plane domain coloring. It is path-based complex graphing: enter a path z(t), optionally transform it through f(z), and Callie Pro plots the resulting real and imaginary values.

3D Surface mode plots:

z = f(x, y)

Examples:

x^2 + y^2
sin(x)*cos(y)
sin(x - t)
sin(x)*cos(t)

Static 3D surfaces use x and y. Temporal 3D surfaces can also use t, which lets the surface move during playback.

Use 3D Surface mode for:

• Terrain-like surfaces.
• Wave surfaces.
• Potential wells.
• Height fields.
• Multivariable functions.

Mesh Quality

3D surfaces are sampled as a mesh. Higher mesh settings can look smoother, but they require more computation.

Use lower mesh settings when:

• You are animating a Temporal surface.
• The expression is expensive.
• The surface has many sharp features.
• You want the app to stay very responsive.

Use higher mesh settings when:

• Playback is paused.
• You want a cleaner export.
• You are inspecting a static surface.

Callie Pro skips invalid points such as NaN, infinity, and singularities when possible, so expressions like 1/sqrt(x^2+y^2) do not force the camera to frame impossible values.

3D Controls

The 3D graph area includes controls for:

• Surface mesh.
• Contours.
• Slices.
• 3D analysis updates.
• Trace center.
• Diagnostics and summaries.

These controls stay in the graph workspace, below or near the 3D canvas, so you can adjust the render without leaving the graph.

3D Curve / Vector mode plots a path in 3D:

x(t) = ...
y(t) = ...
z(t) = ...

Example:

x(t) = cos(t)
y(t) = sin(t)
z(t) = t
t min = 0
t max = 2*pi

This creates a helix.

For a simple vector from the origin, enter:

x(t) = 0.95*t
y(t) = 0.02*t
z(t) = 0.40*t
t min = 0
t max = 1

Callie Pro renders the curve from start to end and can show an endpoint marker/arrow direction when appropriate.

Use 3D Curve / Vector mode for:

• Vectors.
• Helices.
• Space curves.
• Parametric paths.
• Motion traces.

Complex 3D Surface mode plots a real height surface over the complex input plane.

You enter:

f(z) = ...

Callie Pro treats:

z = x + i*y

Then it evaluates f(z) over the selected real and imaginary ranges. The horizontal axes represent:

• Re(z)
• Im(z)

The vertical height is chosen by height mode:

• |f(z)|
• arg(f(z))
• Re(f(z))
• Im(f(z))

Example: z^2

Enter:

z^2

With height mode:

|f(z)|

This shows the magnitude of z^2 over the complex plane.

At z = 1 + i:

z^2 = 2i
|z^2| = 2

Example: 1/z

Enter:

1/z

This has a singularity at zero. Callie Pro skips invalid samples instead of stretching the surface into misleading spikes or crashing the render.

Example: ln(z)

Enter:

ln(z)

Try height mode:

Im(f(z))

This can reveal branch behavior in the complex logarithm.

Example: sin(z)

Enter:

sin(z)

Try height mode:

|f(z)|

This shows how the magnitude of the complex sine changes across the input plane.

Complex 3D is useful for visualizing complex functions as surfaces. It is not domain coloring; it is a height-surface view.

Temporal graph types add playback over a parameter, usually t.

Temporal Mode is built into dedicated temporal graph types rather than attached globally to every graph. That keeps ordinary graphing stable and makes playback behavior easier to understand.

Temporal graph types include:

• Temporal Function.
• Temporal Parametric.
• Temporal Polar.
• Temporal Complex.
• Temporal 3D Surface.

Temporal controls appear only for Temporal graph types.

Controls include:

• Play and Pause.
• Step backward.
• Step forward.
• Speed.
• Loop.
• Timeline or progress.
• Current t.

Temporal Function

Use Temporal Function for a real-valued graph that changes with time.

Example:

y = sin(x - t)
t min = 0
t max = 2*pi

As t advances, the wave translates.

Temporal Parametric

Use Temporal Parametric for motion along a parametric path.

Example:

x(t) = cos(t)
y(t) = sin(t)
t min = 0
t max = 2*pi

Playback moves the marker around the circle.

Temporal Complex

Use Temporal Complex for complex paths.

Example:

z(t) = e^(i*t)
t min = 0
t max = 2*pi

Playback moves around the unit circle on the complex plane.

Another example:

z(t) = e^(i*t) + cos(t)

This creates an offset complex path with a changing real component.

Temporal 3D Surface

Use Temporal 3D Surface for a surface that changes with time.

Examples:

z = sin(x - t)

A translating wave.

z = sin(x)*cos(t)

A standing wave.

z = sin(sqrt((x-t)^2 + y^2))

A moving ripple.

z = e^(-((x-t)^2 + y^2))

A moving Gaussian.

During playback, Callie Pro uses performance protections so the app stays responsive. Static surfaces can remain cached while temporal surfaces update. Playback may use lower-resolution preview meshes, then restore fuller quality when paused.

Synced Temporal Playback

When compatible Temporal expressions are visible together, Callie Pro can synchronize them with a shared scene clock.

This is useful for comparing multiple temporal fields that should move under the same t range.

For example, a multi-layer Temporal 3D Surface scene might include:

Y1 = -1/sqrt(x^2 + y^2 + 0.03^2)
Y2 = 0.35*e^(-80*((x-cos(t))^2 + (y-sin(t))^2))

The first surface is static. The second surface changes with t. Callie Pro keeps the static surface stable and updates the temporal surface during playback.

Temporal Safety

Temporal playback uses the same numeric safety rules as static graphing:

• Non-finite values are skipped.
• Unsafe graph values are rejected.
• Heavy 3D playback is throttled.
• Camera fitting is kept stable during playback.
• Editing an expression stops playback.

If a formula becomes invalid, playback stops or reports a clear problem rather than trying to render nonsense.

Trace lets you inspect graph values directly on the curve.

Use Trace when you want to answer:

• What is the value here?
• Where am I on the curve?
• What is the current x, y, t, or theta?
• What is the complex value at this point?
• What is the 3D point under the trace?

Starting Trace

Open TRACE or use trace controls from the graph.

For 2D graphs, trace moves along sampled curve points. Left and right move through the curve. Hold-to-repeat lets the trace continue moving while you hold the arrow.

For complex paths, trace reports:

• t
• z
• Re(z)
• Im(z)
• |z|
• arg(z)

For 3D curves, trace reports:

• t
• x
• y
• z

For 3D surfaces, trace can inspect the current surface slice or point depending on the graph type.

Tap-To-Trace

When available, tapping near a curve moves trace to a nearby sampled point. After that, arrow tracing continues normally along the sampled curve.

Tap-to-trace is meant to help you get close quickly. Fine movement still comes from the trace arrows.

Analysis Markers

Analysis tools can create markers for:

• Roots.
• Minimums.
• Maximums.
• Intersections.
• Derivatives and slopes.
• Tangents when explicitly requested.

Repeated analysis actions refresh existing markers instead of stacking duplicate overlays for the same expression and role.

The Table workspace shows numerical values for graph expressions.

Use Table when you want to inspect values without manually tracing point by point.

For a standard function, table rows usually show:

• x
• expression value
• status if a value cannot be evaluated

For complex graph mode, the table uses complex-specific columns:

• t
• Re(z)
• Im(z)
• |z|
• arg(z)

This means a complex table does not simply say that a result is complex. It shows the real and imaginary information in a useful form.

For z(t)=e^(i*t), useful rows include:

t = 0       Re = 1       Im = 0       |z| = 1
t = pi/2    Re = 0       Im = 1       |z| = 1
t = pi      Re = -1      Im = 0       |z| = 1
t = 3pi/2   Re = 0       Im = -1      |z| = 1
t = 2pi     Re = 1       Im = 0       |z| = 1

For 3D and Complex 3D modes, table views focus on the sampled quantities that make sense for the active expression, such as input coordinates, output components, magnitude, argument, and selected height.

The Window workspace controls graph bounds.

For 2D graphs, the main window values are:

• x min
• x max
• y min
• y max

For parameterized graphs, domain fields may also appear:

• t min
• t max
• samples

For 3D surfaces, you may also work with:

• x range
• y range
• z or height fit
• mesh resolution

Fit

Fit asks Callie Pro to frame visible finite graph content in the canvas.

Use Fit when:

• A graph appears too small.
• A graph is off-screen.
• You have zoomed or panned too far.
• You loaded a new expression and want a sensible view.

Fit ignores invalid samples, non-finite values, and skipped singularities. A single impossible spike should not ruin the view.

Zoom

Zoom In and Zoom Out change the visible range.

Callie Pro prevents unsafe numeric zoom extremes. If you attempt to zoom too far in or out, the app stops at a safe graph limit rather than letting the renderer collapse into numeric artifacts.

When a limit is reached, the app may show a small message such as:

Zoom limit reached

Reset

Fit or reset-style actions recover a sane graph view after panning, zooming, or rotating.

Use these when the graph is technically valid but no longer framed in a useful way.

Graph analysis tools help you find important features of a graph.

Depending on graph type and expression, tools may include:

• Root.
• Minimum.
• Maximum.
• Intersection.
• dy/dx.
• Tangent.
• Trace.

Root

Root analysis finds where a curve crosses zero.

For:

x^2 - 4

the roots are:

x = -2
x = 2

If you tap Root again, Callie Pro refreshes the root markers instead of adding duplicate copies.

dy/dx

dy/dx reports slope information.

For:

y = x^2

at:

x = 2

the slope is:

4

dy/dx uses compact slope markers. It does not draw a full tangent line unless you explicitly choose a tangent-style analysis.

Minimum And Maximum

Minimum and Maximum analysis finds local or visible extrema when the expression and sampled region support it.

Use Fit and Window controls to focus on the region you care about before relying on extrema.

Intersection

Intersection analysis compares visible expressions and finds crossing points where possible.

This is helpful when comparing models, solving approximate equations visually, or checking where two curves agree.

The calculator scratch area is for direct computation.

Use it for:

• Arithmetic.
• Scientific functions.
• Constants.
• Complex values.
• Quick checks before graphing.

Examples:

2 + 2
sin(pi/2)
asin(1)
sqrt(-4)
e^(i*pi) + 1
gcd(15, 12)
lcm(15, 28)

Expected results include:

2 + 2 = 4
sin(pi/2) = 1
asin(1) = 1.57079632679
sqrt(-4) = 2i
e^(i*pi) + 1 = 0
gcd(15, 12) = 3
lcm(15, 28) = 420

Calculator memory is designed for calculator-style work:

• M+ adds to memory.
• M- subtracts from memory.
• MR recalls memory.
• MC clears memory.

Memory is meant to persist until you clear it.

CAS is the computer algebra workspace. Use it when you want symbolic or exact-style help instead of only numeric graphing.

CAS operations include:

• Simplify.
• Factor.
• Expand.
• Solve.
• nsolve.
• Derivative.
• Integral.
• Limit.
• Matrix determinant.

Simplify

Simplify reduces an expression when possible.

Examples:

sin(x)^2 + cos(x)^2

Expected:

1

e^(i*pi)

Expected:

-1

Factor

Factor rewrites expressions into products.

Example:

x^2 - 4

Expected:

(x - 2)(x + 2)

Expand

Expand rewrites products or powers into expanded form.

Example:

(x + 1)^2

Expected:

x^2 + 2*x + 1

Solve

Solve finds symbolic solutions when possible.

Example:

x^2 - 4

Expected:

x = -2, 2

nsolve

nsolve is numerical solving. It uses an initial guess.

Use nsolve when:

• An equation is hard to solve symbolically.
• You want a numeric root near a starting point.
• You know approximately where the answer should be.

Derivative

Derivative computes a symbolic derivative.

Example:

x^2

Expected:

2*x

Integral

Integral computes an antiderivative when possible.

Example:

sin(x)

Expected:

-cos(x)

Limit

Limit evaluates expression behavior near a point.

Example:

sin(x)/x

with approach:

0

Expected:

1

Matrix Determinant In CAS

CAS can compute a determinant from matrix text.

Accepted forms include:

[[1,2],[3,4]]

and:

[1,2],[3,4]

Expected determinant:

-2

Malformed matrix text should return a clear syntax problem rather than a misleading result.

Complex CAS

CAS supports user-friendly complex notation.

Examples:

i
1i
2i
3+4i
3-4i
i^2
sqrt(-4)
(1+i)^2
e^(i*pi)
cos(pi) + i*sin(pi)

Expected results include:

i
i
2i
3 + 4i
3 - 4i
-1
2i
2i
-1
-1

The parser treats i as the imaginary unit only when it is actually a complex token. Ordinary names such as sin, limit, initial, and pi are not rewritten as imaginary expressions.

The Matrix workspace is for matrix entry and matrix operations.

Use Matrix for:

• Determinant.
• Inverse.
• RREF.
• Rank.
• Trace.
• Transpose.
• Solving Ax=b.
• Eigen operations.

Entering A Matrix

Use the grid editor or paste matrix text when available.

Example:

[1, 2]
[3, 4]

or:

[[1,2],[3,4]]

Determinant

For:

[[1,2],[3,4]]

determinant is:

-2

Inverse

The inverse of a square nonsingular matrix can be calculated from the Matrix workspace.

If a matrix is singular, Callie Pro reports that it cannot compute the inverse rather than returning invalid values.

RREF

RREF converts a matrix to reduced row echelon form.

Use it for:

• Solving linear systems.
• Checking rank.
• Understanding row dependencies.

Solve Ax=b

For systems of equations, enter matrix A and vector b, then solve.

The result is shown as variables such as:

x1 = ...
x2 = ...
x3 = ...

Eigen

Eigen output can be long, especially for larger matrices. Each matrix result card is meant to be readable, individually copyable, and clearable from history.

Matrix History

Matrix operations create result cards. You can review previous results, copy individual cards, and clear history when you want a fresh workspace.

Clear History removes all Matrix history cards, including long eigen output and error cards.

The Stats workspace is for descriptive statistics, confidence intervals, and hypothesis tests.

Use Stats when you have data and want summaries or inference.

Common tasks include:

• Enter a dataset.
• Compute summary statistics.
• Run confidence intervals.
• Run hypothesis tests.
• Export dataset CSV.

Dataset Entry

Enter numeric values in the dataset area. Depending on the active tool, values may be separated by lines, commas, or table-style input.

Use clear labels in your own notes so you remember what each dataset represents.

Descriptive Statistics

Stats can summarize a dataset with values such as:

• Count.
• Mean.
• Median.
• Standard deviation.
• Minimum and maximum.
• Quartiles when available.

Confidence Intervals

Confidence intervals estimate a range for a population value from sample data.

Use them when you want a statement such as:

The mean is estimated to be within this range at the selected confidence level.

Choose the interval type that matches your data and question.

Hypothesis Tests

Hypothesis tests compare data against a claim or comparison value.

Use them when you want to test questions such as:

• Is the mean different from a target?
• Is a proportion different from a claimed value?
• Is a difference statistically meaningful under the selected assumptions?

Callie Pro reports the relevant test output and keeps the workflow inside the calculator workspace.

Stats Export

Stats datasets can be exported as CSV. On iPad, the export creates a persistent file and opens the standard share sheet so you can save or send it.

The Python workspace lets you write and run small local scripts for numerical work.

It is designed for calculator-style scripts, not for installing packages or building external apps.

Use Python for:

• Numerical checks.
• Small loops.
• Formula exploration.
• Vector calculations.
• Data transformations.
• Generating graph points through supported app bridges.

Script Editor

The script editor is the main text area. It is scrollable, so longer scripts stay inside the editor rather than pushing the workspace around.

Use LTTR for text entry. The directional pad becomes text navigation while LTTR is active.

Helpful keys:

• SPC inserts a space.
• TAB inserts indentation.
• ENTER inserts a newline.
• DEL deletes text.
• Arrows move the cursor.

Running A Script

Tap Run Script to execute the current visible script buffer.

Output appears in the output panel. Errors appear there as well, so you can correct the script without leaving the workspace.

Copying And Clearing Output

Use:

• Copy Output to copy the latest output text.
• Clear Output to clear only the output panel.
• Clear Script to clear the current script after confirmation.
• Reset Runtime to reset runtime state without replacing the script.

Example: Basic Loop

for i in range(5):
    print(i)

Expected output:

0
1
2
3
4

Example: Lists And Comprehensions

xs = [-3, -2, -1, 0, 1, 2, 3]
ys = [x*x - 4 for x in xs]
print(ys)

Expected output:

[5, 0, -3, -4, -3, 0, 5]

Example: Dot Product

def dot(a, b):
    return sum(x*y for x, y in zip(a, b))

print(dot([1, 2], [3, 4]))

Expected output:

11

Example: Math Module

from math import gcd

print(gcd(15, 12))

Expected output:

3

Python Sandbox Limits

The Python workspace runs locally inside a restricted calculator sandbox.

The sandbox is intended for visible, user-written numerical scripts. It is not designed for:

• Downloading code.
• Installing packages.
• Accessing the network.
• Spawning processes.
• Reading or writing arbitrary files.
• Modifying app features.

If a script attempts something outside the calculator sandbox, Callie Pro blocks it and reports the issue.

The Catalog helps you find functions, constants, and insertable terms without memorizing every key layer.

Use Catalog when you need:

• A trig function.
• A logarithm.
• A hyperbolic function.
• Complex functions.
• Constants.
• Engineering values.
• Special functions that are easier to search than type.

Examples of useful entries include:

sin(
cos(
tan(
asin(
acos(
atan(
sqrt(
ln(
log10(
gamma(
gcd(
lcm(

Constants and engineering values can help with applied calculations. Use them as references or insert them into compatible fields when available.

Callie Pro can export graph and data artifacts.

Available export types include:

• PNG.
• PDF.
• CSV.
• JSON.
• SVG.

Stats can also export dataset CSV.

On iPad, exports use the standard iPadOS share sheet. The flow is:

1. Choose an export type from the File/export controls.
2. Callie Pro generates the file.
3. The file is saved in the app's Downloads/CalliePro location.
4. The iPadOS share sheet opens.
5. Choose Save to Files, AirDrop, Mail, Copy, or another available action.

Canceling the share sheet does not delete the generated file.

PNG Export

PNG exports are image exports of the graph view.

Use PNG when you want:

• A quick visual.
• A web image.
• A screenshot-like graph artifact.
• A file to drop into a document or presentation.

PDF Export

PDF exports include a graph page and report-style context.

Graph PDF reports can include:

• The graph.
• Equations.
• Window settings.
• Annotations.
• Table preview.

Use PDF when you want a more complete saved explanation of the graph.

CSV Export

CSV exports are best for data.

Graph CSV exports can include:

• Graph metadata.
• Equations.
• Window context.
• Table preview.
• Additional workspace sections when relevant.

Use CSV when you want to analyze or archive values outside the app.

JSON Export

JSON exports are structured graph-document data.

Use JSON when you want a machine-readable representation of the graph document.

SVG Export

SVG exports create scalable vector graph output.

SVG is useful for:

• Web graphics.
• Scalable diagrams.
• Design workflows.
• Clean line-art style graph output.

Graph SVG exports include metadata so the file carries more context than only the visible plot.

Callie Pro is built as a local calculator workspace.

Core behavior:

• No account is required.
• Calculations run locally.
• Graph documents are local.
• Matrix, Stats, CAS, and Python workspaces run inside the app.
• Python is sandboxed for calculator-style numerical scripts.
• Exports are generated as files you choose to save or share.

The app does not require a sign-in workflow to use the calculator, graphing, CAS, Matrix, Stats, Python, or export features.

The graph is blank

Check:

• Is the expression visible?
• Is the expression valid for its graph type?
• Is the window range appropriate?
• Does the expression produce real values in a real graph mode?
• Would Complex Graph mode be more appropriate?

Try:

1. Tap Y= and confirm the expression.
2. Tap GRAPH.
3. Tap Fit.
4. Check Table for evaluation messages.

The graph is too small or off-screen

Use Fit.

If the graph still looks wrong:

• Check for extreme values.
• Narrow the window.
• Hide other expressions.
• Reduce 3D mesh complexity if the expression is heavy.

A 3D surface has holes

Holes usually mean some sampled points were invalid or singular.

Examples:

• Division by zero.
• Logarithm branch behavior.
• Infinite or non-finite results.
• Values beyond safe graph limits.

This is often better than drawing misleading spikes.

Temporal playback feels heavy

Try:

• Lowering mesh resolution.
• Hiding nonessential 3D surfaces.
• Using a simpler expression.
• Pausing playback before increasing mesh quality.
• Using Fit before playback starts.

Temporal 3D surfaces can be computationally expensive. Callie Pro uses preview meshes and throttling to keep the app responsive, but very heavy formulas can still take more time.

A CAS result is not what you expected

Check:

• Did you choose the right CAS operation?
• Did you specify the variable?
• For limit, did you set the approach value?
• For nsolve, did you choose a reasonable initial guess?
• Is your matrix syntax valid?

Try simplifying the expression first or testing a smaller expression in the calculator scratch area.

Python did not run

Check:

• Is the script visible in the editor?
• Did you tap Run Script?
• Is there an error message in output?
• Did the script try to use a blocked module or system feature?

Python is intentionally sandboxed. Keep scripts focused on local numerical work.

Matrix operation failed

Check:

• Determinant and inverse require square matrices.
• Inverse requires a nonsingular matrix.
• Solve Ax=b requires compatible dimensions.
• Eigen output may be long for larger matrices.
• Matrix text must be valid rectangular numeric data.

Export did not go where expected

After choosing an export type, use the iPadOS share sheet to decide where the file goes.

If you cancel the share sheet, the generated file still remains in Callie Pro's export location. Run the export again if you want to send it somewhere else.

If you are new to Callie Pro, try this sequence.

1. Basic Graph

Enter:

Y1 = sin(x)

Open GRAPH, then TRACE.

Move along the curve with the arrows.

2. Compare Two Functions

Enter:

Y1 = sin(x)
Y2 = 0.2*x^2 - 2

Use GRAPH, TABLE, and TRACE.

Try intersection analysis if available for the visible curves.

3. Complex Graph

Create a Complex graph:

z(t) = e^(i*t)
t min = 0
t max = 2*pi

Trace the path and watch Re, Im, |z|, and arg.

4. 3D Surface

Create a 3D Surface:

z = sin(x)*cos(y)

Use Fit, rotate the view, and try mesh or contour controls.

5. Temporal Surface

Create a Temporal 3D Surface:

z = sin(x - t)
t min = 0
t max = 2*pi

Press Play and observe the wave movement.

6. CAS

Open CAS and try:

sin(x)^2 + cos(x)^2

Choose Simplify.

Then try:

x^2 - 4

Choose Factor or Solve.

7. Matrix

Open Matrix and enter:

[[1,2],[3,4]]

Run determinant and inverse.

8. Stats

Enter a small dataset and compute descriptive statistics. Then try a confidence interval or hypothesis test if it matches your data.

9. Python

Open Python and run:

xs = [-3, -2, -1, 0, 1, 2, 3]
ys = [x*x - 4 for x in xs]
print(ys)

Copy the output, clear it, and try a second script.

10. Export

Return to a graph and export:

• PNG for a quick image.
• PDF for a graph report.
• CSV for table/context data.
• SVG for scalable graph artwork.
• JSON for structured graph document data.

• Use Y= to define, GRAPH to inspect, TRACE to explore, TABLE to verify, and WINDOW to frame.
• Use Fit whenever a graph looks lost.
• Use Complex Graph mode when a real graph reports complex values.
• Use Temporal graph types only when you want playback.
• Keep heavy 3D meshes lower during playback and higher when paused.
• Use CAS for symbolic work and the calculator scratch area for fast numeric checks.
• Use Matrix for structured linear algebra rather than forcing matrix text through the calculator.
• Use Python for small custom numerical scripts, loops, and data checks.
• Export PDF when you want context, not just an image.
• Export CSV when values matter more than visuals.

CAS

Computer algebra workspace for operations such as simplify, factor, expand, solve, derivative, integral, limit, nsolve, and determinant.

Complex Graph

A graph mode that plots complex outputs using real values on the horizontal axis and imaginary values on the vertical axis.

Complex 3D Surface

A graph mode that evaluates f(z) across the complex input plane and maps magnitude, argument, real part, or imaginary part to height.

Fit

A graph action that frames visible finite graph content inside the canvas.

LTTR

The calculator shell's letter/text entry mode.

Matrix Workspace

Workspace for matrix input, determinant, inverse, RREF, rank, trace, transpose, solve Ax=b, and eigen operations.

Mesh

The sampled grid used to draw a 3D surface.

Temporal Graph

A dedicated graph type that supports playback over a time-like parameter t.

Trace

A graph exploration mode that moves through points and reports values.

Window

The graph bounds and viewing range.

Callie Pro is meant to feel like a mathematical workspace rather than a stack of separate tools. The graph, calculator shell, CAS, Matrix, Stats, Python, Catalog, and export flows are designed to stay close together so you can move from question to expression to visualization to result without rebuilding your context.

Start with one expression. Trace it. Table it. Change the window. Then try Complex, 3D, Temporal, CAS, Matrix, Stats, and Python as the problem asks for them.