CalculusCalculator v2.1.0 Help

The following applies to all text input boxes

0. Interface Structure and Menus

Since v2.1.0, all former standalone feature tabs have been integrated into the All-in-One page, making the interface much simpler. The current menu bar and tab structure:

Menu bar

Tabs

There are 6 kinds of tabs: Home, All-in-One, Help, Settings, Cache, and Blockly Editor. Multiple tabs of the same kind can be open at once (titles are auto-numbered); tabs can be closed and reordered by dragging.

All-in-One page

The All-in-One page is the main interface for all kinds of computation, divided left-to-right into three areas whose widths can be adjusted by dragging the splitters:

1. Define area: choose a type from the top dropdown (Function, Set, Vector, Plane Geometry, Solid Geometry) to define functions and objects; objects are grouped by type in the tree list and can be read or deleted.
2. Compute area: choose a computation type from the dropdown (Compute, Derivative, Integral, Equation, Inequality, System of Equations, System of Inequalities, Plane Compute, Solid Compute, Transform, Solve Triangle — 11 in total); the input rows adapt to the selected type.
3. Plot area: choose a mode from the dropdown (Plane Geometry mode, Solid Geometry mode, Function mode), check the objects to draw, then click Plot or Update to generate the image.

1. Direct LaTeX Code Input

Besides the standard Python/SymPy syntax below, you can enter LaTeX code directly. Prefix the LaTeX code with a half-width dollar sign $; the system converts the LaTeX expression into a SymPy expression automatically.

Usage:

2. Math Symbol Input Standard

1. Addition / subtraction / multiplication / division: + - * /
2. Power: ** (e.g. x**2 means x squared)
3. Square root: sqrt()
4. Absolute value: abs()
5. Logarithm log_a(x): log(x, a)
6. Natural log ln(x): log(x)
7. Trig functions: sin() cos() tan() cot() sec() csc()
8. Inverse trig functions: asin() acos() atan() acot() etc.
9. Hyperbolic functions: sinh() cosh() tanh() etc.
10. Euler's number: e
11. Pi: pi
12. Positive / negative infinity: oo / -oo
13. Parentheses: round brackets () work everywhere
14. Imaginary unit: I

Examples:

3. Set / Interval Input Standard

1. Roster form: FiniteSet(1,2,3)
2. Set-builder form: ImageSet(Lambda(x, f(x)), Domain)
3. Built-in sets:
   • Real numbers: Reals
   • Complex numbers: Complexes
   • Natural numbers: Naturals
   • Non-negative integers: Naturals0
   • Integers: Integers
   • Rationals: Rationals
   • Empty set: EmptySet
4. Intervals:
   • Closed [x,y]: Interval(x,y)
   • Left-open (x,y]: Interval.Lopen(x,y)
   • Right-open [x,y): Interval.Ropen(x,y)
   • Open (x,y): Interval.open(x,y)
5. Union: Union(A,B)
6. Intersection: Intersection(A,B)
7. Complement / difference: Complement(A,B), where A is the universal set

Examples:

FiniteSet use cases

• In the Define area of the All-in-One page with the "Function" type, use FiniteSet(1,2,3) in the function domain input to restrict the domain to the discrete set {1,2,3}
• In the Compute area with the "Equation" type, use FiniteSet(0,1) in the principal variable range input to solve only for roots within that set
• Combine with set operations: Union(Interval(0,1), FiniteSet(2)) represents the union of interval [0,1] and point 2

ImageSet use cases

• Define a mapped set: ImageSet(Lambda(x, x**2), Interval(0, 5)) represents {x² | x∈[0,5]}
• Periodic solutions with trig functions: the solution set of sin(x)=0 can be written as ImageSet(Lambda(n, n*pi), Integers), where n is an integer
• Describe a complex range in the Define area's domain input: ImageSet(Lambda(x, 2*x+1), Integers) represents the set of all odd integers

4. Function Input Standard

For a function already defined in the Define area of the All-in-One page, you can use it directly in most other input boxes:

• As a symbol in operations: e.g. if g(x)=x**2 is defined, entering g+1/g yields x**2 + 1/x**2
• As a function call with arguments: e.g. if f(x)=x**2 is defined, entering f(3) computes 3**2 = 9 automatically; nested calls such as f(g(2)) are supported

5. Denominator Rationalization

In modules such as derivative, integral, equation solving, and expression simplification, if the denominator of a result contains a radical, the system automatically rationalizes the denominator, simplifying the result into its simplest form where both numerator and denominator are integral or radical expressions.

6. Computation Engines

In the Compute area of the All-in-One page with the "Compute" type, four computation engines are supported:

1. Python built-in engine: uses Python's built-in eval to quickly compute numeric expressions; results are shown as plain text
2. Mpmath high-precision engine: customizable decimal precision, suitable for high-precision numeric computation; results are shown as plain text
3. Sympy symbolic engine: performs symbolic computation based on Sympy; results are displayed both as LaTeX code and as plain text.
4. Latex code generation engine: generates the corresponding Latex code directly from the input Python expression

7. Vector Features

In the Define area of the All-in-One page with the "Vector" type, you can define 2D vectors and perform vector operations.

Define a vector

1. Vector name: defaults to v, customizable
2. Vector x/y coordinates: enter the x and y components separately, supporting SymPy expressions (e.g. sqrt(3), pi/2)
3. Click Save to add the vector to the list, or Delete to remove the selected vector

Vector properties

• Expression: displays the vector in coordinate form
• Magnitude: the length of the vector, i.e. sqrt(x² + y²)
• Direction angle: the angle between the vector and the positive x-axis
• Unit vector: a vector with the same direction and magnitude 1

Vector operations

1. Select two defined vectors from the dropdown
2. Select the operation type: addition, subtraction, dot product, angle
3. Click Compute; the result is displayed both as rendered LaTeX and as plain text

8. Triangle Solving

In the Compute area of the All-in-One page with the "Solve Triangle" type, enter the known conditions of a triangle to solve for the remaining unknowns.

Condition input

1. Three condition boxes, each with a type selectable from the dropdown: angle A, angle B, angle C, side a, side b, side c
2. Fill in the values in the corresponding input boxes, supporting SymPy expressions (e.g. pi/3, sqrt(2))
3. Exactly 3 valid conditions must be filled in

Supported cases

9. Function Plotting

In the Plot area of the All-in-One page with "Function mode" selected, you can plot function graphs.

Usage

1. Expression mode: enter the function expression directly (e.g. x**2, sin(x))
2. Select function mode: check functions defined in the Define area
3. Set the left/right endpoints of the domain (default [-10, 10]), supporting SymPy expressions
4. Click Plot or Update to generate the graph

Features

• Rendered with Matplotlib, with clearly labeled axes
• Automatically handles discontinuities (e.g. 1/x breaks at x=0)
• The y-axis auto-scales to the visible range

10. Plane Geometry

In the Define area of the All-in-One page with the "Plane Geometry" type, define points, lines, segments, circles, triangles, and polygons, then visualize them in the Plot area with "Plane Geometry mode".

Define objects

1. Select a creation method from the dropdown (19 in total)
2. Enter the object name
3. Enter the parameters (separated by half-width English commas)
4. Press Enter or click the Save button to create the object

Supported creation methods

Plotting

In the Plot area with "Plane Geometry mode", all defined objects are checked by default. Uncheck the ones you don't need, then click Plot or Update to generate the Matplotlib image.

11. Solid Geometry

In the Define area of the All-in-One page with the "Solid Geometry" type, define 3D points, lines, planes, and segments, then visualize them in the Plot area with "Solid Geometry mode".

Supported methods

Plotting

In the Plot area with "Solid Geometry mode", filter objects via checkboxes, then click Plot or Update to generate a 3D rotatable Matplotlib image (with transparent planes and colored lines).

12. Plane Geometry Calculation

In the Compute area of the All-in-One page with the "Plane Compute" type, use defined points, lines, circles, triangles, polygons, etc. for geometric computation. Parameters are separated by half-width English commas, and defined objects are referenced by name.

Supported operations (32 in total)

13. Solid Geometry Calculation

In the Compute area of the All-in-One page with the "Solid Compute" type, use defined 3D points, lines, planes, etc. for spatial geometric computation.

Supported operations (22 in total)

14. Differential Equation Input Standard

Differential equation input does not follow the function input standard above, because the solution is unknown before solving. The system excludes all defined functions when parsing the expression to avoid interference, and the function to solve for is fixed as f(x).

In the input, use f(x).diff(x,n) to denote the n-th derivative with respect to x. The 1 can be omitted, so f(x).diff(x) denotes the first derivative.

Example: in the Compute area select "Equation" and check "Differential Equation", enter f(x).diff(x,1) on the left and f(x)+1 on the right, completing the input of f'(x)=f(x)+1; click Solve to get f(x)=C1*exp(x)-1.

15. Settings, Language and Theme

Open the settings page via the menu bar "File → Settings" to configure the following:

1. Interface language: Chinese / English. Takes effect immediately and is persisted; restored automatically on next launch.
2. Interface theme: Light / Dark. Takes effect immediately and is persisted; restored automatically on next launch.
3. English help: the help page switches automatically with the interface language; selecting English loads the English help (see help_en.html in this page's English version).

Both settings are saved as JSON under the Qt standard configuration directory (typical path AppData/Local/CalculusCalculator/CalculusCalculator/settings.json), with content such as {"language": "zh_CN", "theme": "dark"}.

Via the menu bar "File → Save / Open" you can save the current workspace (including theme and language) as a project file, which restores the saved theme and language when opened.

16. Expression Cache

Temporarily store and manage commonly used expressions via the "Cache" feature, in two ways:

Cache tab

1. Open the cache tab via the menu bar "File → Cache" to display all cached expressions
2. Double-click any cached item in the list to copy its text to the clipboard
3. The cache list in the tab syncs in real time with the main window's cache data

Input box quick buttons

Each text input box has three icon quick buttons on its right:

17. Visual Formula Input

A visual math formula input panel based on MathLive (bundled in the math_input/ directory). Since v2.0.0, the formula editor's underlying engine has been replaced with MathLive, offering a smoother input experience and more accurate symbol rendering.

Usage

1. Click the keyboard icon button on the right of any input box to open the formula dialog
2. In the dialog, use the toolbar to select math structures (fractions, roots, sub/superscripts, Greek letters, etc.), operators, or functions
3. After editing, click OK; the formula is automatically converted to a SymPy expression and filled into the input box

Toolbar groups

• Structure: fraction, root, power, absolute value, parentheses, etc.
• Greek letters: common Greek letters α~ω
• Edit: undo, redo, cut, etc.
• Operators: +, -, ×, ÷, =, ≠, etc.
• Functions: sin, cos, log, lim, etc.

18. Save Settings

On the "Save Settings (when saving)" area of the settings page, you can fine-tune which types of information are saved via checkboxes:

19. Blockly Feature

Open the Blockly editor via "Features → Editor" and build a visual computation flow by dragging and snapping blocks together, completing complex computations without writing code. Currently supported:

• Sympy / Latex expression input: blocks can directly take SymPy expressions, or use a leading $ for LaTeX input (see "1. Direct LaTeX Code Input").
• Run the flow directly in the editor: click Run to execute the block-built flow in order, showing intermediate results in real time.
• Automatic output formula rendering: results are automatically rendered as clear, good-looking math formulas in LaTeX.
• Dual-mode code preview: click "Preview code" and use the dropdown to switch between native SymPy code (self-contained, only requires SymPy - copy and run directly in any interpreter with SymPy installed) and CalculusCalculator library code (the code actually executed by the Run button); native SymPy code is shown by default.
• Define function / function analysis: define functions via blocks and analyze their domain, monotonicity, parity, etc.
• Derivative / integral: use the corresponding blocks to differentiate or integrate a function.
• Equation(s) / inequality(ies) / triangle solving: use solving blocks to handle equations, inequalities, and triangles.
• Project save / load: Blockly projects can be saved and loaded, controlled by the "Save Settings" item in "Settings" (see "18. Save Settings").

20. Splash Screen and Startup Optimization

A splash screen shows progress and hints while the program loads resources, avoiding a blank wait during startup. v2.1.0 further optimizes the startup flow:

• Lazy browser engine initialization: the QWebEngine kernel is no longer loaded at startup; instead it is initialized automatically when the Blockly editor or the visual formula input is opened for the first time, speeding up startup.
• Lightweight splash screen: the splash screen is drawn and shown faster, giving visible feedback sooner.
• Streamlined initialization: redundant refreshes of formula rendering views are skipped at startup.
• Combined with the existing lazy-loading (lazy_loader) mechanism, the overall startup speed is optimized.

Additional Resources

The above content fully references the language specifications of Python 3.12 and SymPy 1.14.

If you have questions, please refer to:

1. Python official docs: https://docs.python.org/3.12/
2. SymPy official docs: https://docs.sympy.org/latest/index.html
3. Mpmath official docs: https://mpmath.readthedocs.io/en/latest/

Version History

Thank you for using it!

LiMingkang

2026/10/10