iMemo+ - Complex Number Calculator

iMemo+ is a calculation memo extension for VS Code. Write expressions alongside your notes in Markdown imemo code blocks or standalone .imemo files, and view results, variables, and complex vectors in a results panel.

This is an independent implementation inspired by the original iMemo (Complex Memo). See Differences from the original iMemo at the end of this page for the supported scope and compatibility differences.

Installation and quick start

Use desktop VS Code 1.140.0 or later. Development and verification have focused on macOS. Windows, VS Code for the Web, and remote environments have not been verified; virtual workspaces are not supported.

1. Open the Extensions view and search for @id:fujiitk.imemop.
2. Install iMemo+ - Complex Number Calculator published by fujiitk.
3. Open a Markdown (.md) file or create a .imemo file. In Markdown, place expressions in an imemo code block; in .imemo, write expressions directly in the document.
4. Right-click in the editor and select iMemo+: Show Calculation Results, or run the command from the Command Palette.

Copy this example into a Markdown file. The first block calculates 20 and the second calculates 4; their ordinary variables are independent:

# Calculation notes

```imemo
; First calculation
x=10
x*2
```

```imemo
; Second calculation
x=3
x+1
```

Editing recalculates automatically by default. If automatic calculation is off, use iMemo+: Recalculate. Results do not modify your document. Saving and Undo/Redo use the normal VS Code workflow; uninstalling the extension leaves your documents and settings in place.

The extension's commands, settings, results panel, and diagnostics support English and Japanese. They follow VS Code's display language, using Japanese for Japanese and English for other languages. Restart VS Code after changing its display language. This listing is in English; expression syntax is the same in both languages.

If you previously installed tkworks.imemo-plus or fujiitk.imemo-plus, disable or uninstall the old extension before installing fujiitk.imemop. The publisher and package name identify a separate extension, so the new ID is installed separately. Your Markdown and .imemo files and iMemo-plus.* settings can still be used.

Features

• Evaluate multiple Markdown calculation blocks and standalone .imemo documents.
• Calculate with real and complex numbers, decimal and scientific notation, engineering prefixes, binary and hexadecimal integers, and polar coordinates.
• Extract the low hexadecimal digits or binary bits with hex(value, digits) and bin(value, digits), retaining a zero-padded base-prefixed display.
• Keep exact rational values for supported arithmetic within implementation limits; use approximate values for transcendental functions and other approximate operations.
• Create numeric arrays and matrices with complex elements, use 1-based indexing, and calculate matrix products, transposes, determinants, inverses, linear-system solutions, and elementwise operations.
• Define variables and user functions, reuse the previous result with Ans, and share _ variables with later blocks in the same document.
• Calculate parallel resistance, fixed dB conversions, voltage-based dBm/dBu conversions, and basic statistics with real or complex samples.
• Display complex values as arrows with magnitude and phase using vect ... end.
• View expressions and results in a panel beside the editor or in the sidebar, inspect local and global variables, and jump to a block's source.
• Copy successful calculations as Markdown tables from Markdown documents, or as tab-separated text from .imemo files.
• Choose Rad/Deg and normal, fixed decimal, exponential, or engineering output; configure precision, automatic calculation, and undefined-variable handling.
• See errors and warnings in the results panel and VS Code diagnostics. Standalone .imemo documents also show successful results beside their source lines.

Commands

Open the Command Palette and search for iMemo+. The following are the nine available commands. Command IDs can also be used in VS Code keyboard shortcuts.

The results panel shows the document name, Recalculate, Copy All Results, and a short calculation status at the top. Expand Calculation settings to change Rad/Deg, display format, or automatic calculation; the collapsed summary shows their current values. The angle and format pickers identify the current value and where a change will be saved. Open VS Code Settings… is inside this section and opens the extension's seven settings. An empty view offers Create a sample memo with sample expressions.

Variables at the end of each block and global variables at the end of the document appear in separate, initially collapsed lists with counts. Expand a list to inspect its values. Recalculation preserves your choice in the same document; switching documents resets it. Blocks with no assigned variables have no empty variable list. Array and matrix results use a full-width row below their expression, with row and column indices and scrolling within the element table. Copying includes all successful results and all elements, even when a variable list is closed.

Each block has Go to and Copy actions. A block's first nonempty comment can supply its name. Copying is available for successful, current results, with success or failure reported in the panel. While the same document awaits recalculation or is calculating, previous results remain visible with a notice, and Copy and Go to are unavailable. Switching documents clears the previous document's results.

For Markdown documents, Copy Results places __Table__ Block name before each table, separated by a blank line. Table is a fixed label in both UI languages and renders in bold without adding a document heading. Block names are preserved as literal text; unnamed blocks use the UI language's default name. Blocks without successful results are omitted. A block's Copy action copies only its four-column table, with the fixed English headers Expression, Result, Unit, and Comment in either UI language. For .imemo files, whole-document copying uses # Block name and tab-separated expressions and results.

The panel follows VS Code's fonts and theme. Updating the same document preserves settings expansion, vector visibility, scrolling, and focus on the same available result control within the open view. If that control disappears, focus moves to Recalculate. Vector groups can be collapsed, and their checkboxes show or hide individual arrows; numbered labels also identify the arrows.

Expression syntax

Names are case-insensitive. Use = or := for assignment, ; for a comment to the end of a line, and [text] for an inline comment. Square brackets are comments, not array syntax. Function arguments must be separated by a comma followed by an ASCII space, as in sum2(4, 7).

Engineering prefixes are z a f p n u m c h k M G T P; m and M have different meanings. Numeric suffixes Hz, ohm, Ω, V, A, F, H, and W are accepted as labels, without dimensional analysis or automatic unit conversion. User functions are local to their block; recursive functions are not supported. Same-named user functions take precedence over built-ins.

Available functions and constants

Ordinary mathematical and engineering functions require one argument. hex and bin require two arguments: an integer value and a digit count. Scalar constants, Ans, and statistical values accept zero or one argument; an argument multiplies the value. When Ans is an array or matrix, parentheses select its elements; Ans() returns the whole value. Collection functions are described below. Data and End have the separate control behavior described under Basic statistics.

Append D or R to Sin, Cos, Tan, Asin, Arcsin, Acos, Arccos, Atan, Arctan, Arg, Angle, or Phase to force degrees or radians. Examples: SinD(90), AsinR(1), PhaseD(3+4i). The unsuffixed forms follow the selected angle unit.

For dBm, the input is voltage in volts, referenced to 1 mW into 50 ohms: the reference voltage is sqrt(50e-3) V. dBm(1V) is approximately 13.0103; AdBm(0) is approximately 0.223607 V.

For dBu, iMemo+ follows the original iMemo source's 1 microvolt reference. dBu(1uV) returns 0, dBu(1V) returns 120, and AdBu(20) returns approximately 0.00001 V. This is the original iMemo convention; do not assume a different reference from the function name.

Forward dB conversions use complex magnitude; inverse conversions use only the real part and return an approximate real value. Zero magnitude in a forward conversion is an error. A non-finite result is an error, while underflow in approximate calculations can produce zero. yR and AyR report division by zero when their real input becomes zero.

Arrays and matrices

Create an array by separating two or more scalar expressions with a comma and an ASCII space. Arrays are row vectors (1×N); a single value remains a scalar. Use matrix name ... end for a rectangular matrix, including a 1×1 or column matrix:

a = 1, 2, 3, 5
a(3)                  ; 3
b = a*2               ; 2, 4, 6, 10
emul(a, a)            ; 1, 4, 9, 25
dot = a*transpose(a)   ; 1×1: (39)
dot(1, 1)             ; 39
matrix A
    1, 2
    3, 4
end
A(1, 2)               ; 2
A*A                   ; 2×2: (7, 10), (15, 22)
transpose(A)          ; 2×2: (1, 3), (2, 4)

Indices start at 1 and must be positive real integers within the dimension. Arrays require one index; matrices require row and column indices, even for a 1×1 result. Scalar x(2) still means x*2. Existing built-in names keep their function-call precedence; use names such as dot or A for indexed values rather than an existing function name such as S. Newly added collection-function names can be shadowed by an assigned variable or user function.

Matrix rows accept scalar expressions, including complex values, or one existing array. Blank lines and comments are ignored. Empty or uneven rows are errors. The matrix is assigned only after its matching end and a successful definition; failure preserves the previous variable, shared value, Ans, and statistics. Matrix definitions cannot contain assignments, function definitions, statistics controls, or nested matrix/vect groups.

Arrays and matrices can be assigned to _ globals, passed to and returned from user functions, and reused through Ans. Mathematical, radix, and statistical functions require scalar arguments: use Abs(a(1)), hex(a(1), 2), or >a(1). A collection is not automatically expanded into statistical samples or vector arrows; select a scalar element inside vect.

Each input or result is limited to 1,000 elements, together with the existing expression, document, and calculation-time limits. The panel shows dimensions and numbered, scrollable tables; copied values retain every element as 1, 2, 3, 5 or 2×2: (1, 2), (3, 4). The completed matrix result belongs to its matrix A line. This output notation is for display and copying; use the input syntax above to define a matrix.

Update a defined array or matrix with = or :=:

a = 1, 2, 3
b = a
a(2) = 10             ; Result and Ans: 10
a                     ; 1, 10, 3
b                     ; 1, 2, 3 (the earlier value)
matrix A
    1, 2
    3, 4
end
A(1, 2) := 5          ; Result and Ans: 5
A                     ; 2×2: (1, 5), (3, 4)

Index expressions are evaluated from left to right before the right-hand value. The target must already be an array or matrix, indices must be in range, and the inserted value must be a scalar real or complex number. The shape does not expand. On success, the row result and Ans are the inserted scalar, while the variable table shows the updated collection. Aliases such as b=a and earlier results keep their previous values. On failure, the target, globals, Ans, and statistics retain their previous state. _ collection updates are visible from the successful assignment onward in the same document. Element assignment to Ans itself is not supported; assign the collection to a named variable first.

Calculate determinants, inverses, and linear-system solutions:

matrix A
    2, 1
    1, 3
end
b = 5, 10
det(A)                ; 5
Ai = inv(A)           ; 2×2: (0.6, -0.2), (-0.2, 0.4)
x = solve(A, b)       ; 1, 3
x(2)                  ; 3
A*Ai                  ; 2×2: (1, 0), (0, 1)
A*transpose(x)        ; 2×1: (5), (10)
transpose(A)          ; 2×2: (2, 1), (1, 3)
matrix R
    5, 1
    10, 3
end
solve(A, R)           ; 2×2: (1, 0), (3, 1)

The coefficient A must be a square matrix, including when it has one element. Arrays and scalars are not implicitly converted into coefficient matrices. For an N×N coefficient matrix, an array b must have N elements, or a matrix right-hand side must have N rows. A scalar right-hand side is not accepted: for a one-equation system, use a 1×1 matrix. Names are case-insensitive, so b and B refer to the same variable; the example uses Ai for the inverse.

solve uses elimination and back-substitution directly. inv and solve require an invertible coefficient matrix; their errors preserve prior assignments, globals, Ans, and statistics. Exact inputs retain rational arithmetic within the existing digit limits. If any coefficient or right-hand element is approximate, the calculation uses floating-point approximations and row pivoting. Only a zero pivot is treated as singular; there is no near-singularity tolerance, and rounding or underflow can affect approximate results. Inputs and previous results remain unchanged. transpose swaps rows and columns without changing the signs of imaginary parts.

Slicing, conjugate transpose, rectangular least-squares systems, and matrix powers are planned for later work.

Global variables

Start a variable name with _ to share its value with later lines and blocks in the same document:

```imemo
_R=50
```

```imemo
10/_R      ; 0.2
_R=100
10/_R      ; 0.1
```

Blocks and lines are evaluated from top to bottom. A definition or reassignment affects later calculations only; earlier results and vector arrows retain the value at their evaluation time. Before definition, a reference follows the undefined-variable setting: zero with a warning, or an error. Failed assignments preserve the previous value.

Every recalculation rebuilds shared state from the document. Separate documents remain independent. Ordinary variables, Ans, function definitions, and statistics are local to each block. Function parameters remain local even when their names start with _. _CONST is a shared variable that can be reassigned, not a read-only constant.

The panel shows global values at the end of the document and local values at the end of each block. Variable names are displayed in lowercase. From version 0.1.21, existing _ variables become shared; remove the leading _ if they should remain local. The same rules apply in .imemo files.

Binary and hexadecimal integers

Use 0b/0B for binary and 0x/0X for hexadecimal integers. The original integer forms &1010, &c1111 (two's complement), and $FF also work.

r = 0b00       ; 0
x = 0x00       ; 0
a = 0b1010     ; 10
b = 0xFF       ; 255
a+b            ; 265
c = -0xFF      ; -255

Base-prefixed input alone follows the selected display format; normal output uses decimal values. Use the functions below for explicit binary or hexadecimal output. Base-prefixed fractional values, digit separators, missing digits, and invalid digits are not supported. Hexadecimal A-F are case-insensitive. To apply an engineering multiplier, write 0x10*1k.

Low hexadecimal digits and binary bits

Use hex(value, digits) to extract the low hexadecimal digits, or bin(value, digits) to extract the low binary bits. These functions return an unsigned integer that remains usable in calculations:

a = 0x2412       ; 9234
b = hex(a, 2)    ; 0x12 (numeric value 18)
b               ; 0x12
b + 1           ; 19
bin(a, 8)       ; 0b00010010
hex(15, 4)      ; 0x000F
hex(-1, 2)      ; 0xFF (numeric value 255)

Both arguments are required. The digit count must be an integer from 1 to 1000, excluding the 0x or 0b prefix. Output is padded with leading zeros, and hexadecimal letters are uppercase. Values wider than the requested width lose their high digits; negative values use two's complement at that width and return the corresponding unsigned integer.

The value must be a real integer. Fractional values and nonzero imaginary parts are errors. Exact integers retain their precision within the implementation's limits. Approximate values are accepted only when they are integers in the safe range from -9007199254740991 to 9007199254740991; an approximate input may already have lost precision before it reaches these functions.

The returned value retains its base and width through variable assignment, direct references, Ans, _ globals, parentheses, unary + inside an expression, and user functions that return the value directly. This explicit display takes priority over the selected result format and precision. Arithmetic, unary -, and ordinary conversion functions create normally formatted results; the original value is unchanged. To retain a chosen base after arithmetic, wrap the new result in hex or bin again.

Results, variable lists, vector value labels, and copied tables or tab-separated text retain this display. Vector coordinates, magnitude, and phase use the numeric value. Statistics calculate numerically; operations that return an original sample, such as MinA and MaxA, retain that sample's display. Invalid calls report a line error and preserve previously assigned values and Ans.

Complex vector display

Wrap the calculation lines to plot in vect and a standalone end:

v=10+5i
vect
    r=50+3i
    v
end

The vector section shows arrows from the origin to each value's real (Re) and imaginary (Im) components, with equal scales on both axes. The legend shows the value, magnitude, and phase. Use checkboxes to show or hide arrows and the heading to collapse a plot.

Each arrow retains the value when its line is evaluated. Variables assigned inside the group remain available later in the calculation block. Multiple groups create separate plots; nesting and missing closing lines are errors. Standalone vect and end are reserved control lines; use End() for statistics.

Phase follows Rad/Deg. Zero has no plotted phase. Coordinates, magnitude, and phase are approximate; values outside the safe drawing range keep their calculation results and show an explanation. Comments, function definitions, and failed lines do not produce arrows.

Plots update on recalculation. Visibility is retained for unchanged document/block/group/line identities and resets when their identity changes. Visibility is temporary and is not saved in the document.

Basic statistics

Use Data() to clear statistics and start collection. Prefix sample expressions with > and use End() to stop collection while retaining the collected values:

Data()
>10
>20
>30
End()
Count() ; 3
Sum()   ; 60
Ave()   ; 20
Std()   ; 10

Complex samples are supported. Variance is real and uses squared distances from the complex mean. Variance and standard deviation return zero for zero or one sample. MinA() and MaxA() retain the sample's sign and imaginary part.

End() returns the sample count. Only successful > rows during collection add samples. Ordinary rows and > rows outside collection calculate without adding samples. Errors preserve the previous statistics, Ans, and assignments. In the default undefined-variable mode, a warning row calculated as zero also counts as a sample; select error mode to exclude it.

Statistics are local to each block and reset on recalculation. Sum and Sum() both read the total; Sum(2) returns twice the total. Data and End accept zero or one scalar argument, evaluate the argument, and then ignore its value. Normal-distribution functions are not available.

Copying and navigating results

Click Copy in a block heading to copy successful calculations from that block. Markdown documents produce a four-column table with English headers, regardless of the UI language. For example, a = 5 [V] ; Supply voltage produces:

| Expression | Result | Unit | Comment |
| --- | --- | --- | --- |
| `a = 5` | `5` | `V` | `Supply voltage` |

Bracketed annotations before the end-of-line comment go into Unit, without [ and ]. Multiple annotations, such as [V] [rms], become V rms. The first ; outside square brackets starts Comment; that delimiter is removed, and subsequent semicolons and brackets remain part of the comment. Leading and trailing whitespace in units and comments is trimmed. Missing units or comments produce empty cells. Any bracketed inline comment becomes a unit annotation when copied; use ; for explanatory text. This copies labels without unit conversion or dimensional analysis.

The Expression cell omits these annotations, while Result keeps its calculation format. Arrays and matrices retain all elements. A matrix result uses units and comments on its matrix opening line; body rows and end do not become separate copied results.

Copy Results copies all blocks with headings and a separate table for each block. Blocks without results, error rows, and function definitions without results are omitted. Headers are always English; user text and block names are preserved. Units and comments are separated only during Markdown copying; the source document and the panel's expression/result display stay unchanged. Standalone .imemo documents use tab-separated text.

Go to moves the editor to the start of a calculation block. Calculating and copying results do not write them back into the source document.

Settings

Find iMemo+ in VS Code Settings, or use these keys in settings.json:

License

The project's own implementation and documentation are provided under the MIT License below. Third-party code and materials remain subject to their respective terms; third-party license notices are included in the extension. Original iMemo reference materials are not bundled. Development, distribution, maintenance, and support for iMemo+ are handled by this project; direct iMemo+ questions to its publisher.

MIT License

MIT License

Copyright (c) 2026 tkworks

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Differences from the original iMemo

This comparison uses the original iMemo Ver. 6.5 help and publicly released source as the reference. It describes features, not verified numerical equivalence: the original application has not been run for side-by-side comparison. The original source release may also differ from its distributed binary. See the original iMemo website for the original application.

iMemo+ implements a selected subset plus VS Code-specific features. It is not a complete replacement for the original iMemo. Array and matrix syntax described above is an iMemo+ addition; original-file or MATLAB compatibility is not implied.