CalculusCalculator v2.0.0 Help

The following are common standards for all text box inputs

0. Direct LaTeX Code Input

In addition to the standard Python/SymPy syntax below, this version supports entering LaTeX code directly. Prefix the LaTeX code with a half-width dollar sign $ as a marker, and the system will automatically convert the LaTeX expression into a SymPy expression for computation.

Usage:

1. Mathematical Symbol Input Standard

1. Add/sub/mul/div: + - * /
2. Power: ** (e.g. x**2 means x squared)
3. Square root: sqrt()
4. Absolute value: abs()
5. General logarithm log_a(x): log(x, a)
6. Natural logarithm ln(x): log(x)
7. Trigonometric functions: sin() cos() tan() cot() sec() csc()
8. Inverse trigonometric 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 parentheses () are sufficient
14. Imaginary unit: I

Examples:

2. Set / Interval Input Standard

1. Roster method: FiniteSet(1,2,3)
2. Set-builder method: 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
   • Rational numbers: Rationals
   • Empty set: EmptySet
4. Intervals:
   • Closed interval [x,y]: Interval(x,y)
   • Left-open right-closed (x,y]: Interval.Lopen(x,y)
   • Left-closed right-open [x,y): Interval.Ropen(x,y)
   • Open interval (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 function domain input on the "Define" page, use FiniteSet(1,2,3) to restrict the domain to the discrete set {1,2,3}
• In the principal variable range input on the "Equation" page, use FiniteSet(0,1) 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 domain on the "Define" page: ImageSet(Lambda(x, 2*x+1), Integers) represents the set of all odd integers

3. Function Input Standard

For a function already defined on the "Define" 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

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

5. Compute Tab

Three 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

6. Vector Features

On the "Define Vector" page, 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

7. Triangle Solving

On the "Solve Triangle" page, 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

8. Function Plotting

On the "Plot Function" page, you can plot function graphs.

Usage

1. Expression mode: enter the function expression directly (e.g. x**2, sin(x))
2. Select function mode: choose a function defined on the "Define" page from the dropdown
3. Set the left/right endpoints of the domain (default [-10, 10]), supporting SymPy expressions
4. Click the Plot button 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

9. Plane Geometry

On the "Plane Geometry" page, define points, lines, segments, circles, triangles, and polygons, then visualize them on the "Plane Plot" page.

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

Switch to the "Plane Plot" page; all defined objects are checked by default. Uncheck the ones you don't need, then click Plot or Update to generate the Matplotlib image.

10. Solid Geometry

On the "Solid Geometry" page, define 3D points, lines, planes, and segments, then visualize them in 3D on the "Solid Plot" page.

Supported methods

Plotting

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

11. Plane Geometry Calculation

On the "Plane Compute" page, 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)

12. Solid Geometry Calculation

On the "Solid Compute" page, use defined 3D points, lines, planes, etc. for spatial geometric computation.

Supported operations (22 in total)

13. Enter Shortcut and Menu Adjustment

1. Enter shortcut: pressing Enter in the main text input box of each page automatically triggers the corresponding function button (e.g. "Derivative", "Integral", "Compute", "Save"), without manually clicking.
2. Menu bar adjustment: a "Compute" item is added to the menu bar, containing "Plane Compute", "Solid Compute", and the original "Compute" (general computation), for clearer categorization.
3. Help page optimization: the help page now auto-adjusts its layout with the window instead of being a fixed size.

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: 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 "Features → 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 pyqt5-math-widget (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, or open the formula dialog via the menu "Edit → Formula Input"
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. Menu Adjustment

1. The "Solve Triangle" feature moved from its standalone location to a sub-item of the "Solve" menu
2. The "Transform" feature moved to a sub-item of the "Compute" menu
3. A "Cache" sub-item is added under the "File" menu bar, clicking it opens the cache tab
4. Project structure optimization: added __init__.py to the core/ directory; refactored ui/i18n.py into core/settings.py

20. Blockly Feature (new in v2.0.0)

A new "Blockly" feature lets you build a visual computation flow by dragging and snapping blocks together, completing complex computations without writing code. Open the block editor on the "Blockly" page. Currently supported:

• Sympy / Latex expression input: blocks can directly take SymPy expressions, or use a leading $ for LaTeX input (see "0. 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").

21. Splash Screen and Startup Optimization (new in v2.0.0)

A new splash screen shows progress and hints while the program loads resources, avoiding a blank wait during 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/8/14