ND1 Visual Guide to Capabilities


Keys, stack and display

ND1 has two key layouts, “Modern” and “Classic”, and a selection of skins:

(ND1 Modern, “Dark” skin. This picture reduced from full iPhone 4 resolution.)

When you tap the Menu key, a pop-up dialog of soft-menu choices appears.

Tap one, and that menu’s functions appear on the soft-keys.

ND1 features 400+ functions. Many operate on more than one kind of data.

For example, there’re more than 20 different operations tied to the “+” key.

(It adds numbers, complex numbers, vectors, matrices, binary numbers, big integers, colors, chemical formulas; it appends strings, an object to a list of objects; etc.)

The tab bar will slide up, which allows you to switch to the calculator’s Definition page (change keys and menus), Help page (access online documentation), and My Data page (manage user folders, upload/download data).

The contents of the pop-up dialog are editable, as almost everything in ND1. You can also place often-used keys on it. (The ↓stack key is a key that contains a small RPL program which will package up the stack and save it.)

(ND1 Modern, “Dark” skin. iPhone 3G)

“Classic” keys and menus:

(ND1 Classic, “Light” skin. iPhone 3G)

The stack is unlimited. You can flick through it with your finger, and enjoy smooth kinetic scrolling.

Double-tap the stack to expand it:

Expanded, up to 21 stack lines are shown.

ND1 has unprecedented support of data types:



Complex number

Chemical formula (custom types from the Chem shared folder)

Arbitrary-precision big integer

Octal number

Hexadecimal number

Real number

Color object (custom type from the Color shared folder)

Array of Color objects

Screen-shot of a line chart from statistics data

Algebraic expression

Symbolic matrix

Vector containing a complex and a real number

When you tap the edit line, you get the standard iOS keyboard for typing.

The is great for quickly typing a function or variable name, and, of course, for typing text and programs.

(In our experience, it’s easily 4x faster to type programs with this keyboard than using a non-QWERTY calculator’s physical keys.)

Tap Done or tap the display, to dismiss the keyboard.

You can still use soft-keys, and–in “Tab bar showing” mode (entered by tapping the ND1 tab)–one additional row of calculator keys, incl. access to the menu pop-up. (This allows you to switch menus while programming.)

Double-tap the edit line, and the edit line expands to a scrolling text editor.

This is a native editor capable of smoothly scrolling through even a 1000-line program.

RPL programs maintain the formatting with which they were entered. A subset of hp 50g commands is supported. In addition, a toll-free bridge permits calling JavaScript from RPL, without you even knowing.

In JavaScript, MorphEngine creates a very comfortable programming environment. A rich API is available for all object types. RPL functions can be called as if they were JavaScript. JS frameworks or other sources can be dynamically loaded. A Canvas object is available.

pdf (3/20/11)http://naivedesign.com/docs/ND1_VisualGuide.pdf

ND1 is an app for iOS (Android and Kindle versions under development), and a new kind of calculator.

It’s a bit of a hybrid between HP-28S™ and hp 50g™ calculators, and it’s something completely new: a JavaScript calculator with an HTML5/Canvas graphics display.

Highly programmable in JavaScript and RPL (using a command subset of the hp 50g), it aims to be a calculator programmer’s dream machine. Networking and sharing features enable downloadable content and data-exchange with a computer.

For detailed specs, see the Specifications.

If you’ve owned an HP (-28, -48, -49, -50g), please make sure you read the Comparison to HP Calculators.

What is ND1?

Stack and Graphics display

(6 lines, or 320x134 pixels)

Double-tap to expand

(20 lines, or 320x480 pixels)

Edit line with auto-completion

Double-tap to expand

User Data (VAR) access key

Tap to see current user folder, or go up (if already in user folder) and see all

9 Soft-keys

Contents as per active menu

(2nd page of LOGS shown)

Intelligent Backspace and

Undo/Redo key

Drop key

Enter (and DUP) key

2nd function is last (COMMAND)

ND1 is a graphing calculator.

When drawing a graph, multi-touch gestures can be employed for zooming, panning, tracing, trace point to stack, and screenshot functionality.

Double-tap (or tap ) and do all this in full-screen mode.

Multiple graphs can be displayed at the same time.

Having an HTML5 display, many other graphics uses are available with literally a handful of lines of code.

Here’re some:

In the order as displayed:

- a random walker

- a parametric plot

- a {15,7}-star

- a stack of the bits of the first 400 Fibonacci numbers (making BigNum integers visible; details are here)

The HTML5 Canvas object is a modern vector and bitmap graphics surface on which to draw (from either RPL or JavaScript).

The 2nd and 3rd examples above simply compute data points and then utilize the linePlot() function (akin to Mathematica™’s listLinePlot() function) to do an auto-centered and -scaled display.

We have big plans for future graphics support.

WebGL will be supported as soon as it’s available in WebKit, and this will permit real-time 3-D graphics in ND1, with full programmability.

Independently, we’ll support compute-kernels on the GPU. Something like computing the Mandelbrot set will run a whopping one million times (!) faster than on an HP calculator.



ND1 is a high-end calculator. There’re many things you can use it for. Describing them all is beyond the scope of this guide, but here’s a cross-section of abilities, by data type.

Real number

A real number                                factorial (! or FACT)                mantissa (MANT)

loggamma                              acsch (inverse hyperbolic cosecant)    ln (LN) [yielding complex result]

(commands applied consecutively)

Complex number

A complex expression                eval (EVAL)

Two complex numbers                * (multiplied)                            atanh (ATANH)

arg (ARG)

(commands applied consecutively)


Vectors (aka arrays) are very strong in ND1.

The calculator consolidates the real, complex, symbolic, and list data types of HP calculators into one array type.

A significant number of functions are devoted to operating on vectors.

Automatic “list processing functions” exist which will apply any function to all vector elements.

A vector (3 data types)                sin (SIN)                                                √ (square root)

A real vector                                            fft (FFT) [fast Fourier transform)        ifft (IFFT) [inverse Fourier transform)

A vector of Color objects                                        1/x (inverted)

3,5,sub (SUB) [extract subarray]

A vector of 1000 random integers                        sort (SORT) [speed: instantaneous]

Two vectors                        cross (CROSS)                     abs (ABS)

A vector of RPL program fragments                        permutate [speed: instantaneous]

                                                                                tapping “(710 more)” displays all elements


A real matrix              its det (DET)           its trace (TRACE)    its rank (RANK)        its triangular [form]

A symbolic matrix and a complex vector        * (multiplied) [theta was ‘π/2’]

A random 100x100 (!) real matrix                   round (RND)

   1/x (invert matrix) [speed: 5s]                           triangular [speed: 1s]                                abs (ABS)


ND1 has an arbitrary-precision integer (BigInt) facility.

Those, and ordinary integers, can be used with base-related functions (convert base, logic bit-wise operations) and special integer functions that ordinarily appear in a calculator’s CAS, such as GCD, LCM, factorization.

A BigInt                                                isPrime (ISPRIME?)        fromBigNum (I→R) [@ 0, FIX]

A hex integer    toOct (OCT)        toBin (BIN)                        shift_right (SR)                    toDec (DEC)

(With ND1, there’s no need to convert a decimal number into a “binary number” before it can participate in base conversions and bit-wise functions; also, mixed bases can appear on the stack simultaneously)

A hex and a binary integer        xor (XOR)                            shift_left_byte (SLB)                toBigNum (R→I)

Two decimal numbers    GCD            LCM        factors (FACTORS)       divs (DIVIS) [divisors]

Integer functions are written to operate on one integer, but they do, of course, participate in list processing:

300, primes (produces primes in [0, 300])         linePlot (w/ keepAspect set to false)

5, - (subtract five from all elements)             factor (FACTOR) (factorize all elements)


ND1 has functions for mean, stddev, variance, correlation, covariance, and linear regressions of statistical data.

Also erf and distributions (Gaussian, Normal, Chi-squared, Fisher-F, Student-t) are available.

In addition, data can be charted:

Given                line∑                                                                    pie∑


ND1 has an extensible unit conversion system with 160 entries. You can add your own entries, and even provide RPL conversion programs (in support of non-factor-based conversions).

Given                    convert (CONVERT)

Web front-end

ND1 lacks built-in CAS functionality (so far). But it has an informal front-end to WolframAlpha™ for Mathematica™-quality answers to math (derivative, integral, Taylor, isolate, solve), and, upon customization, other questions.


isolate from the Solve menu will produce the result on the left.

Double-tap, and return to the stack instantly.

As the display can double-duty as a web-browser, all kinds of web contents can be put at your finger-tips.

In fact, you can type a URL on the command-line and this will send you straight to that website.

There’re commands to load web content and to provide query arguments from the stack.

You can easily use Google to provide a real-time streaming stock quote, for example, and tie it into a calculation.

Or use WolframAlpha™ to query for a chemical compound.

Or have a table of the periodic system handy. Etc. Etc.

Custom types

A unique feature in ND1 is support for custom (user-developed) data types.

This makes the calculator infinitely versatile. It’s very easy to develop a custom type (it can even be done on the device; no computer necessary) and detailed documentation is available.

Here’s an example:

A “Chem” type                               EVAL (rel. molar mass)        /H2O, +

(Color, BigInt, Code, NDImage, URL, are other examples for custom types; full sources are provided.)


What can you calculate with ND1?




Do you need direct keys for trigonometry? Or are you willing to do with 4 visible stack positions in exchange for an extra 6 soft-keys? Want often-used extra keys on the menu pop-up? Or make your own functions part of a calculator menu?

You can do all of this on ND1’s Definition page.

Here’s where you change skins (you can even provide your own key bitmaps and have your very own, unique skin), and where you can define, edit, delete from, add to, any of the calculator’s keys and menus.

You can also restore the calculator to factory defaults (and/or pick up new key and menu definitions that come with updates), and examine JavaScript injections, if enabled in Settings.

Under “ND1”, the Settings app gives you access to a good bunch of other customizations, such as what key and menu layout (Modern or Classic) you want, and where you want to see your stack (on the left, or on the right).


Customizing keys and menus

User data is managed in “folders”, and there’s an interface that allows you to manage it.

Shared folders are available for downloading.

Downloading one is as simple as tapping it.

Shared folders provide extensions to the calculator, data, new drawing methods, benchmarking or utility functions, etc.

You can submit work of your own for inclusion in the globally available shared folder download list.

Each folder’s detail page let’s you delete entries, rename them, reorder them, and create new ones (though you’d normally use the calculator’s STO key for that).

In addition, there’s a sharing page, which allows you to upload and download the folder to/from a server. That’s either ours–for your backup and data exchange convenience–or your own server.

(Configuration instructions are provided.)

With matching sharing IDs on two devices, transferring a folder from one MorphEngine calculator to another takes literally two seconds: one, to upload from device A, one, to download to device B.

Data exchange with your own server (that can simply be your computer per WiFi) allows you to work on code on your computer. This can be convenient, though you’ll be surprised how easy it is to work on the device itself.


User data

Thank you for reading through this guide.

You may continue reading the specs, or hurry and download free ND0, and see this all live on your device.

There’s plenty of documentation on this website to help you learn ND1, as a user or as a developer.

We’re long not done with ND1 and MorphEngine. The next version (v1.4) will offer morphing of the calculator UI (our take on “interactivity”) and introduce moving of the stack baseline.

We’re trying to build a new, really cool calculator, and we’d love to have you use it.

What’s next?