EC(1)

NAME
ec - engineering calculator

SYNOPSIS

ec [options] [scripts ...]

OPTIONS

-i, --interactive
    Open an interactive session.

-x, --printx
    Print value of x register upon termination, ignored with interactive sessions.

-s <file>, --startup <file>
    Run commands from file to initialize calculator before any script or interactive session is run, stack is cleared after it is run.

-c, --nocolor
    Do not use colors in the output.

-v, --verbose
    Narrate the execution of any scripts.

-h, --help
    Print the usage and exit.

DESCRIPTION

ec is a stack-based (RPN) engineering calculator with a text-based user interface that is intended to be used interactively.

If run with no arguments, an interactive session is started. If arguments are present, they are tested to see if they are filenames, and if so, the files are opened and the contents are executed as a script. If they are not file names, then the arguments themselves are treated as scripts and executed directly. The scripts are run in the order they are specified. In this case an interactive session would not normally be started, but if the interactive option is specified, it would be started after all scripts have been run.

The contents of ~/.ecrc, ./.ecrc, and the start up file will be run upon start up if they exist, and then the stack is cleared.

STACK

As you enter numbers they are pushed onto a stack. The most recent member of the stack is referred to as the x register and the second most recent is the y register. All other members of the stack are unnamed. Operators consume numbers off the stack to use as operands and then they push the results back on the stack. The operations are performed immediately and there is no use of parentheses to group calculations. Any intermediate results are stored on the stack until needed. For example,
4
6
+

In this case 4 gets pushed on to the stack first to become x. Then 6 gets pushed on to the stack to become x, which makes 4 y. Finally, + pulls both off the stack, sums them, and then pushes the result of 10 back onto the stack. The stack is left with only one number on it, 10.

After each line ec responds by printing the value of the x register. Thus the above example would actually look like this:
0: 4
4: 6
6: +
10:

The benefit of the stack is that it allows you to easily store temporary results while you perform your calculation. For example, to evaluate (34 - 61)*(23 - 56) you would use:
0: 34
34: 61
61: -
-27: 23
23: 56
56: -
-33: *
891:

Notice that you entered the numbers as you saw them in the formula you were evaluating, and there was no need to enter parentheses, however the operators were rearranged in order to express the precedence of the operations.

It is not necessary to type enter after each number or operator. You can combine them onto one line and just type enter when you would like to see the result:
0: 34 61 - 23 56 - *
891:

Furthermore, it is not necessary to type a space between a number and most operators. For example, the above could be entered as:
0: 34 61- 23 56- *
891:

You can print the entire stack using stack, and clear it using clstack. For example,
0: 1 2 3 stack
 3
y: 2
x: 1
3: clstack
0: stack
0:

REAL NUMBERS

Numbers can be entered using normal integer, floating point, and scientific notations. For example,
42
3.141592
5,439,749.97
2.998e8
13.80651e-24

In addition, you can also use the normal SI scale factors to represent either large or small numbers without using scientific notation.

Y   1e24 (yotta)

Z   1e21 (zetta)

E   1e18 (exa)

P   1e15 (peta)

T   1e12 (terra)

G   1e9 (giga)

M   1e6 (mega)

k, K
    1e3 (kilo)

_   unity (1)

m   1e-3 (milli)

u   1e-6 (micro)

n   1e-9 (nano)

p   1e-12 (pico)

f   1e-15 (fempto)

a   1e-18 (atto)

z   1e-21 (zepto)

y   1e-24 (yocto)

    For example, 10M represents 1e7 and 8.8p represents 8.8e-12.

    Optionally, numbers can be combined with simple units. For example,
    10KHz
    3.16pF
    2.5_V
    4.7e-10F

    In this case the units must be simple identifiers (must not contain special characters). For complex units, such as "rads/s", or for numbers that do not have scale factors, it is possible to attach units to a number in the x register by entering a quoted string.
    0: 6.626e-34
    662.6e-36: "J-s"
    662.6e-36 J-s: 50k "V/V"
    50 KV/V:

    The dollar sign ($) is a special unit that is given before the number.
    $100K

    ec takes a conservative approach to units. You can enter them and it remembers them, but they do not survive any operation where the resulting units would be in doubt. In this way it displays units when it can, but should never display incorrect or misleading units. For example:
    0: 100MHz
    100 MHz: 2pi*
    628.32M:

    You can display real numbers using one of three available formats, fix, sci, or eng. These display numbers using fixed point notation (a fixed number of digits to the right of the decimal point), scientific notation (a mantissa and an exponent), and engineering notation (a mantissa and an SI scale factor). You can optionally give an integer immediately after the display mode to indicate the desired precision. For example,
    0: 1000
    1K: fix2
    1000.00: sci3
    1.000e+03: eng4
    1K: 2pi*
    6.2832K:

    Notice that scientific notation always displays the specified number of digits whereas engineering notation suppresses zeros at the end of the number.

    When displaying numbers using engineering notation, ec does not use the full range of available scale factors under the assumption that the largest and smallest would be unfamiliar to most people. For this reason, ec only uses the most common scale factors when outputting numbers (T, G, M, K, m, u, n, p, f, a).

INTEGERS

You can enter integers in either hexadecimal (base 16), decimal (base 10), octal (base 8), or binary (base 2). You can use either programmers notation (leading 0) or Verilog notation (leading ') as shown in the examples below:

0xFF
    hexadecimal

99  decimal

0o77
    octal

0b1101
    binary

'hFF
    Verilog hexadecimal

'd99
    Verilog decimal

'o77
    Verilog octal

'b1101
    Verilog binary

    Internally, ec represents all numbers as double-precision real numbers. To display them as decimal integers, use fix0. However, you can display the numbers in either base 16 (hexadecimal), base 10 (decimal), base 8 (octal) or base 2 (binary) by setting the display mode. Use either hex, fix0, oct, bin, vhex, vdec, voct, or vbin. In each of these cases the number is rounded to the closest integer before it is displayed. Add an integer after the display mode to control the number of digits. For example:
    0: 1000
    1K: hex
    0x3b8: hex8
    0x000003b8: hex0
    0x3b8: voct
    'o1750:

COMPLEX NUMBERS

ec provides limited support for complex numbers. Two imaginary constants are available that can be used to construct complex numbers, j and j2pi. In addition, two functions are available for converting complex numbers to real, mag returns the magnitude and ph returns the phase. They are unusual in that they do not replace the value in the x register with the result, instead they simply push either the magnitude of phase into the x register, which pushes the original complex number into the y register. For example,
0: 1 j +
1 + j: mag
1.4142: pop
1 + j: ph
45 degs: stack
y: 1 + j
x: 45 degs
45 degs:

You can also add the imaginary unit to real number constants. For example,
0: j10M
j10M: -j1u *
10:

Only a small number of functions actually support complex numbers; currently only exp and sqrt. However, most of the basic arithmetic operators support complex numbers.

CONSTANTS

ec provides several useful mathematical and physical constants that are accessed by specifying them by name. The physical constants are given in MKS units. The available constants include:

pi  the ratio of a circle's circumference to its diameter (rads)

2pi the ratio of a circle's circumference to its radius (rads)

rt2 square root of two

0C  0 Celsius in Kelvin (K)

j   imaginary unit (square root of -1)

j2pi
    j*2*pi (rads)

k   Boltzmann constant (J/K)

h   Planck constant (J-s)

q   elementary charge (the charge of an electron) (C)

c   speed of light in a vacuum (m/s)

eps0
    permittivity of free space (F/m)

mu0 permeability of free space (H/m)

Z0  Characteristic impedance of free space (Ohms)

hbar
    Reduced Planck constant (J-s)

me  mass of an electron (g)

mp  mass of a proton (g)

G   universal gravitational constant (m^3/(kg-s^2))

g   standard acceleration of gravity (m/s^2)

R   molar gas constant (J/(mol-K))

NA  Avagadro Number (/mol)

rand
    random number between 0 and 1

    As an example of using the predefined constants, consider computing the thermal voltage, kT/q.
    0: k 27 0C + * q/
    25.865m:

VARIABLES

You can store the contents of the x register to a variable by using an equal sign followed immediately by the name of the variable. To recall it, simply use the name. For example,
0: 100MHz =freq
100 MHz: 2pi* "rads/s" =omega
628.32 Mrads/s: 1pF =cin
1 pF: 1 omega cin* /
1.5915K:

You can display all known variables using vars. If you did so immediately after entering the lines above, you would see:
1.5915K: vars
Rref: 50 Ohms
cin: 1 pF
freq: 100 MHz
omega: 628.32 Mrads/s

Choosing a variable name that is the same as a one of a built-in command or constant causes the built-in name to be overridden. Be careful when doing this as once a built-in name is overridden it can no longer be accessed.

Notice that a variable Rref exists that you did not create. This is a predefined variable that is used in dBm calculations. You are free to change its value if you like.

OPERATORS, FUNCTIONS, NUMBERS AND COMMANDS

In the following descriptions, optional values are given in brackets ([]) and values given in angle brackets (<>) are not to be taken literally (you are expected to choose a suitable value). For example "fix[<N>]" can represent "fix" or "fix4", but not "fixN".

For each action that changes the stack a synopsis of those changes is given in the form of two lists separated by =>. The list on the left represents the stack before the action is applied, and the list on the right represents the stack after the action was applied. In both of these lists, the x register is given first (on the left). Those registers that are involved in the action are listed explicitly, and the rest are represented by .... In the before picture, the names of the registers involved in the action are simply named. In the after picture, the new values of the registers are described. Those values represented by ... on the right side of => are the same as represented by ... on the left, though they may have moved. For example:

x, y, ... => x+y, ...

This represents addition. In this case the values in the x and y registers are summed and placed into the x register. All other values move to the left one place.

  Arithmetic Operators

+: addition The values in the x and y registers are popped from the stack and the sum is placed back on the stack into the x register.

x, y, ... => x+y, ...

-: subtraction The values in the x and y registers are popped from the stack and the difference is placed back on the stack into the x register.

x, y, ... => x-y, ...

*: multiplication The values in the x and y registers are popped from the stack and the product is placed back on the stack into the x register.

x, y, ... => x*y, ...

/: true division The values in the x and y registers are popped from the stack and the quotient is placed back on the stack into the x register. Both values are treated as real numbers and the result is a real number. So
0: 1 2/
500m:

x, y, ... => y/x, ...

//: floor division The values in the x and y registers are popped from the stack, the quotient is computed and then converted to an integer using the floor operation (it is replaced by the largest integer that is smaller than the quotient), and that is placed back on the stack into the x register. So
0: 1 2//
0:

x, y, ... => y//x, ...

%: modulus The values in the x and y registers are popped from the stack, the quotient is computed and the remainder is placed back on the stack into the x register. So
0: 14 3%
2:

In this case 2 is the remainder because 3 goes evenly into 14 three times, which leaves a remainder of 2.

x, y, ... => y%x, ...

chs: change sign The value in the x register is replaced with its negative.

x, ... => -x, ...

recip: reciprocal The value in the x register is replaced with its reciprocal.

x, ... => 1/x, ...

ceil: round towards positive infinity The value in the x register is replaced with its value rounded towards infinity (replaced with the smallest integer greater than its value).

x, ... => ceil(x), ...

floor: round towards negative infinity The value in the x register is replaced with its value rounded towards negative infinity (replaced with the largest integer smaller than its value).

x, ... => floor(x), ...

!: factorial The value in the x register is replaced with its factorial.

x, ... => x!, ...

%chg: percent change The values in the x and y registers are popped from the stack and the percent difference between x and y relative to y is pushed back into the x register.

x, y, ... => 100*(x-y)/y, ...

||: parallel combination The values in the x and y registers are popped from the stack and replaced with the reciprocal of the sum of their reciprocals. If the values in the x and y registers are both resistances, both elastances, or both inductances, then the result is the resistance, elastance or inductance of the two in parallel. If the values are conductances, capacitances or susceptances, then the result is the conductance, capacitance or susceptance of the two in series.

x, y, ... => 1/(1/x+1/y), ...

  Powers, Roots, Exponentials and Logarithms

**: raise y to the power of x The values in the x and y registers are popped from the stack and replaced with the value of y raised to the power of x.

x, y, ... => y**x, ...

aliases: pow, ytox

exp: natural exponential The value in the x register is replaced with its exponential. Supports a complex argument.

x, ... => exp(x), ...

alias: powe

ln: natural logarithm The value in the x register is replaced with its natural logarithm. Supports a complex argument.

x, ... => ln(x), ...

alias: loge

pow10: raise 10 to the power of x The value in the x register is replaced with 10 raised to x.

x, ... => 10**x, ...

alias: 10tox

log: base 10 logarithm The value in the x register is replaced with its common logarithm.

x, ... => log(x), ...

aliases: log10, lg

pow2: raise 2 to the power of x The value in the x register is replaced with 2 raised to x.

x, ... => 2**x, ...

alias: 2tox

log2: base 2 logarithm The value in the x register is replaced with its base 2 logarithm.

x, ... => log2(x), ...

alias: lb

sqr: square The value in the x register is replaced with its square.

x, ... => x**2, ...

sqrt: square root The value in the x register is replaced with its square root.

x, ... => sqrt(x), ...

alias: rt

cbrt: cube root The value in the x register is replaced with its cube root.

x, ... => cbrt(x), ...

  Trigonometric Functions

sin: trigonometric sine The value in the x register is replaced with its sine.

x, ... => sin(x), ...

cos: trigonometric cosine The value in the x register is replaced with its cosine.

x, ... => cos(x), ...

tan: trigonometric tangent The value in the x register is replaced with its tangent.

x, ... => tan(x), ...

asin: trigonometric arc sine The value in the x register is replaced with its arc sine.

x, ... => asin(x), ...

acos: trigonometric arc cosine The value in the x register is replaced with its arc cosine.

x, ... => acos(x), ...

atan: trigonometric arc tangent The value in the x register is replaced with its arc tangent.

x, ... => atan(x), ...

rads: use radians Switch the trigonometric mode to radians (functions such as sin, cos, tan, and ptor expect angles to be given in radians; functions such as arg, asin, acos, atan, atan2, and rtop should produce angles in radians).

degs: use degrees Switch the trigonometric mode to degrees (functions such as sin, cos, tan, and ptor expect angles to be given in degrees; functions such as arg, asin, acos, atan, atan2, and rtop should produce angles in degrees).

  Complex and Vector Functions

abs: magnitude The absolute value of the number in the x register is pushed onto the stack if it is real. If the value is complex, the magnitude is pushed onto the stack.

Unlike most other functions, this one does not replace the value of its argument on the stack. Its value is simply pushed onto the stack without first popping off the argument.

x, ... => abs(x), x, ...

alias: mag

arg: phase The argument of the number in the x register is pushed onto the stack if it is complex. If the value is real, zero is pushed onto the stack.

Unlike most other functions, this one does not replace the value of its argument on the stack. Its value is simply pushed onto the stack without first popping off the argument.

x, ... => arg(x), x, ...

alias: ph

hypot: hypotenuse The values in the x and y registers are popped from the stack and replaced with the length of the vector from the origin to the point (x, y).

x, y, ... => sqrt(x**2+y**2), ...

alias: len

atan2: two-argument arc tangent The values in the x and y registers are popped from the stack and replaced with the angle of the vector from the origin to the point.

x, y, ... => atan2(y,x), ...

alias: angle

rtop: convert rectangular to polar coordinates The values in the x and y registers are popped from the stack and replaced with the length of the vector from the origin to the point (x, y) and with the angle of the vector from the origin to the point (x, y).

x, y, ... => sqrt(x**2+y**2), atan2(y,x), ...

ptor: convert polar to rectangular coordinates The values in the x and y registers are popped from the stack and interpreted as the length and angle of a vector and are replaced with the coordinates of the end-point of that vector.

x, y, ... => x*cos(y), x*sin(y), ...

  Hyperbolic Functions

sinh: hyperbolic sine The value in the x register is replaced with its hyperbolic sine.

x, ... => sinh(x), ...

cosh: hyperbolic cosine The value in the x register is replaced with its hyperbolic cosine.

x, ... => cosh(x), ...

tanh: hyperbolic tangent The value in the x register is replaced with its hyperbolic tangent.

x, ... => tanh(x), ...

asinh: hyperbolic arc sine The value in the x register is replaced with its hyperbolic arc sine.

x, ... => asinh(x), ...

acosh: hyperbolic arc cosine The value in the x register is replaced with its hyperbolic arc cosine.

x, ... => acosh(x), ...

atanh: hyperbolic arc tangent The value in the x register is replaced with its hyperbolic arc tangent.

x, ... => atanh(x), ...

  Decibel Functions

db: convert voltage or current to dB The value in the x register is replaced with its value in decibels. It is appropriate to apply this form when converting voltage or current to decibels.

x, ... => 20*log(x), ...

aliases: db20, v2db, i2db

adb: convert dB to voltage or current The value in the x register is converted from decibels and that value is placed back into the x register. It is appropriate to apply this form when converting decibels to voltage or current.

x, ... => 10**(x/20), ...

aliases: db2v, db2i

db10: convert power to dB The value in the x register is converted from decibels and that value is placed back into the x register. It is appropriate to apply this form when converting power to decibels.

x, ... => 10*log(x), ...

alias: p2db

adb10: convert dB to power The value in the x register is converted from decibels and that value is placed back into the x register. It is appropriate to apply this form when converting decibels to voltage or current.

x, ... => 10**(x/10), ...

alias: db2p

vdbm: convert peak voltage to dBm The value in the x register is expected to be the peak voltage of a sinusoid that is driving a load resistor equal to Rref (a predefined variable). It is replaced with the power delivered to the resistor in decibels relative to 1 milliwatt.

x, ... => 30+10*log10((x**2)/(2*Rref)), ...

alias: v2dbm

dbmv: dBm to peak voltage The value in the x register is expected to be a power in decibels relative to one milliwatt. It is replaced with the peak voltage of a sinusoid that would be needed to deliver the same power to a load resistor equal to Rref (a predefined variable).

x, ... => sqrt(2*10**(x - 30)/10)*Rref), ...

alias: dbm2v

idbm: peak current to dBm The value in the x register is expected to be the peak current of a sinusoid that is driving a load resistor equal to Rref (a predefined variable). It is replaced with the power delivered to the resistor in decibels relative to 1 milliwatt.

x, ... => 30+10*log10(((x**2)*Rref/2), ...

alias: i2dbm

dbmi: dBm to peak current The value in the x register is expected to be a power in decibels relative to one milliwatt. It is replaced with the peak current of a sinusoid that would be needed to deliver the same power to a load resistor equal to Rref (a predefined variable).

x, ... => sqrt(2*10**(x - 30)/10)/Rref), ...

alias: dbm2i

  Constants

pi: the ratio of a circle's circumference to its diameter The value of pi (3.141592...) is pushed on the stack into the x register.

... => pi, ...

2pi: the ratio of a circle's circumference to its radius Two times the value of pi (6.283185...) is pushed on the stack into the x register.

... => 2*pi, ...

rt2: square root of two The square root of two (1.4142...) is pushed on the stack into the x register.

... => sqrt(2), ...

0C: 0 Celsius in Kelvin Zero celsius in kelvin (273.15 K) is pushed on the stack into the x register.

... => 0C, ...

j: imaginary unit (square root of -1) The imaginary unit (square root of -1) is pushed on the stack into the x register.

... => j, ...

j2pi: j*2*pi 2 pi times the imaginary unit (j6.283185...) is pushed on the stack into the x register.

... => j*2*pi, ...

k: Boltzmann constant The Boltzmann constant (R/NA) or 1.3806488e-23 J/K) is pushed on the stack into the x register.

... => k, ...

h: Planck constant The Planck constant (6.62606957e-34 J-s) is pushed on the stack into the x register.

... => h, ...

q: elementary charge (the charge of an electron) The elementary charge (the charge of an electron or 1.602176565e-19 C) is pushed on the stack into the x register.

... => q, ...

c: speed of light in a vacuum The speed of light in a vacuum (2.99792458e8 m/s) is pushed on the stack into the x register.

... => c, ...

eps0: permittivity of free space The permittivity of free space (8.854187817e-12 F/m) is pushed on the stack into the x register.

... => eps0, ...

mu0: permeability of free space The permeability of free space (4e-7*pi H/m) is pushed on the stack into the x register.

... => mu0, ...

Z0: Characteristic impedance of free space The characteristic impedance of free space (376.730313461 Ohms) is pushed on the stack into the x register.

... => Z0, ...

hbar: Reduced Planck constant The reduced Planck constant (1.054571726e-34 J-s) is pushed on the stack into the x register.

... => h/(2*pi), ...

me: mass of an electron The mass of an electron (9.10938291e-28 g) is pushed on the stack into the x register.

... => me, ...

mp: mass of a proton The mass of a proton (1.672621777e-24 g) is pushed on the stack into the x register.

... => mp, ...

G: universal gravitational constant The universal gravitational constant (6.6746e-11 m^3/(kg-s^2)) is pushed on the stack into the x register.

... => G, ...

g: standard acceleration of gravity The standard acceleration of gravity on earth (9.80665 m/s^2)) is pushed on the stack into the x register.

... => g, ...

R: molar gas constant The molar gas constant (8.3144621 J/(mol-K)) is pushed on the stack into the x register.

... => R, ...

NA: Avagadro Number Avogadro constant (6.02214129e23) is pushed on the stack into the x register.

... => NA, ...

  Numbers

<N[.M][S[U]]>: a real number The number is pushed on the stack into the x register. N is the integer portion of the mantissa and M is an optional fractional part. S is a letter that represents an SI scale factor. U the optional units (must not contain special characters). For example, 10MHz represents 1e7 Hz.

... => num, ...

<N[.M]>e<E[U]>: a real number in scientific notation The number is pushed on the stack into the x register. N is the integer portion of the mantissa and M is an optional fractional part. E is an integer exponent. U the optional units (must not contain special characters). For example, 2.2e-8F represents 22nF.

... => num, ...

0x<N>: a hexadecimal number The number is pushed on the stack into the x register. N is an integer in base 16 (use a-f to represent digits greater than 9). For example, 0xFF represents the hexadecimal number FF or the decimal number 255.

... => num, ...

0o<N>: a number in octal The number is pushed on the stack into the x register. N is an integer in base 8 (it must not contain the digits 8 or 9). For example, 0o77 represents the octal number 77 or the decimal number 63.

... => num, ...

0b<N>: a number in binary The number is pushed on the stack into the x register. N is an integer in base 2 (it may contain only the digits 0 or 1). For example, 0b1111 represents the octal number 1111 or the decimal number 15.

... => num, ...

'h<N>: a number in Verilog hexadecimal notation The number is pushed on the stack into the x register. N is an integer in base 16 (use a-f to represent digits greater than 9). For example, 'hFF represents the hexadecimal number FF or the decimal number 255.

... => num, ...

'd<N>: a number in Verilog decimal The number is pushed on the stack into the x register. N is an integer in base 10. For example, 'd99 represents the decimal number 99.

... => num, ...

'o<N>: a number in Verilog octal The number is pushed on the stack into the x register. N is an integer in base 8 (it must not contain the digits 8 or 9). For example, 'o77 represents the octal number 77 or the decimal number 63.

... => num, ...

'b<N>: a number in Verilog binary The number is pushed on the stack into the x register. N is an integer in base 2 (it may contain only the digits 0 or 1). For example, 'b1111 represents the binary number 1111 or the decimal number 15.

... => num, ...

  Number Formats

eng[<N>]: use engineering notation Numbers are displayed with a fixed number of digits of precision and the SI scale factors are used to convey the exponent when possible. If an optional whole number N immediately follows eng, the precision is set to N digits.

sci[<N>]: use scientific notation Numbers are displayed with a fixed number of digits of precision and the exponent is given explicitly as an integer. If an optional whole number N immediately follows sci, the precision is set to N digits.

fix[<N>]: use fixed notation Numbers are displayed with a fixed number of digits to the right of the decimal point. If an optional whole number N immediately follows fix, the number of digits to the right of the decimal point is set to N.

hex[<N>]: use hexadecimal notation Numbers are displayed in base 16 (a-f are used to represent digits greater than 9) with a fixed number of digits. If an optional whole number N immediately follows hex, the number of digits displayed is set to N.

oct[<N>]: use octal notation Numbers are displayed in base 8 with a fixed number of digits. If an optional whole number N immediately follows oct, the number of digits displayed is set to N.

bin[<N>]: use binary notation Numbers are displayed in base 2 with a fixed number of digits. If an optional whole number N immediately follows bin, the number of digits displayed is set to N.

vhex[<N>]: use Verilog hexadecimal notation Numbers are displayed in base 16 in Verilog format (a-f are used to represent digits greater than 9) with a fixed number of digits. If an optional whole number N immediately follows vhex, the number of digits displayed is set to N.

vdec[<N>]: use Verilog decimal notation Numbers are displayed in base 10 in Verilog format with a fixed number of digits. If an optional whole number N immediately follows vdec, the number of digits displayed is set to N.

voct[<N>]: use Verilog octal notation Numbers are displayed in base 8 in Verilog format with a fixed number of digits. If an optional whole number N immediately follows voct, the number of digits displayed is set to N.

vbin[<N>]: use Verilog binary notation Numbers are displayed in base 2 in Verilog format with a fixed number of digits. If an optional whole number N immediately follows vbin, the number of digits displayed is set to N.

  Variable Commands

=<name>: store value into a variable Store the value in the x register into a variable with the given name.

... => ...

<name>: recall value of a variable Place the value of the variable with the given name into the x register.

... => name, ...

vars: print variables List all defined variables and their values.

  Stack Commands

swap: swap x and y The values in the x and y registers are swapped.

x, y, ... => y, x, ...

dup: duplicate x The value in the x register is pushed onto the stack again.

x, ... => x, x, ...

alias: enter

pop: discard x The value in the x register is pulled from the stack and discarded.

x, ... => ...

alias: clrx

stack: print stack Print all the values stored on the stack.

clstack: clear stack Remove all values from the stack.

... =>

  Miscellaneous Commands

rand: random number between 0 and 1 A number between 0 and 1 is chosen at random and its value is pushed on the stack into x register.

... => rand, ...

`<text>`: print text Print "text" (the contents of the back-quotes) to the terminal. Generally used in scripts to report and annotate results. Any instances of $N or ${N} are replaced by the value of register N, where 0 represents the x register, 1 represents the y register, etc. Any instances of $Var or ${Var} are replaced by the value of the variable Var.

"<units>": set the units of the x register The units given are applied to the value in the x register. The actual value is unchanged.

x, ... => x "units", ...

about: print information about this calculator

quit: quit (:q or ^D also works) alias: :q

help: print a summary of the available features

?[<topic>]: detailed help on a particular topic A topic, in the form of a symbol or name, may follow the question mark, in which case a detailed description will be printed for that topic. If no topic is given, a list of available topics is listed.

HELP

You can use help to get a summary of the various features available in EC along with a short summary of each feature. For more detailed information, you can use '?'. If you use '?' you will get a list of all available help topics. If you use '?<topic>' where topic us either a symbol or a name, you will get a detailed description of that topic.

INITIALIZATION

At start up ec reads and executes commands from files. It first tries '~/.ecrc' and runs any commands it contains if it exists. It then tries './.ecrc' if it exists. Finally it runs the startup file specified on the command line (with the -s or --startup option). It is common to put your generic preferences in '~/.exrc'. For example, if your are a physicist with a desire for high precision results, you might use:
eng6
h 2pi / "J-s" =hbar

This tells ec to use 6 digits of resolution and predefines hbar as a constant. After all of the startup files have been processed, the stack is cleared.

SCRIPTING

Command line arguments are used as scripts. If the argument corresponds to an existing file, the file is opened its contents are executed. Otherwise, the argument itself is executed (often it needs to be quoted to protect its contents from being interpreted by the shell). The arguments are executed in the order given. When arguments are given the calculator by default does not start an interactive session and does not produce output. If you wish to use an interactive session after scripts have been evaluated, use the -i or --interactive command line options. If you wish to produce output, which you certainly will if you are not using the interactive session, you must add print commands to your script, which is a double-quoted string. For example,
0: `Hello world!`
Hello world!
0:

You can add the values of registers and variables to your print statements. $N prints out the value of register N, where 0 is the x register, 1 is the y register, etc. $name will print the value of a variable with the given name. Alternatively, you can use ${N} and ${name} to disambiguate the name or number. To print a dollar sign, use $$. To print a newline or a tab, use \n and \t. For example,
0: 100MHz =freq
100 MHz: 2pi* "rads/s"
628.32 Mrads/s: `$freq corresponds to $0.`
100 MHz corresponds to 628.32 Mrads/s.
628.32 Mrads/s:

To illustrate the use of a script, assume that a file named lg exists and contains a calculation for the loop gain of a PLL,
=freq
88.3u "V/per" =Kdet
9.07G "Hz/V" =Kvco
2 =M
8 =N
2 =F
freq 2pi* "rads/s" =omega
Kdet Kvco* omega/ M/ =a
N F* =f
a f* =T
`Open loop gain = $a\nFeedback factor = $f\nLoop gain = $T`

Notice that it starts by saving the value in the x register to the variable freq. This script would be run as:
$ ec 1KHz lg
Open loop gain = 63.732
Feedback factor = 16
Loop gain = 1.0197K

The first argument does not correspond to a file, so it is executed as a script. It simply pushes 1KHz onto the stack. The second argument does correspond to a file, so its contents are executed. The script ends with a print command, so the results are printed to standard output as the script terminates.

Generally if you do not issue a print command in a script, there is no output. However, if you specify the -x or --printx command line option the value of the x register is printed upon termination. An example of how this could be useful is:
$ ec -x 1.52e-11F
15.2 pF

In this example, ec is used simply to convert a number into the more readable engineering notation.

One issue with command line scripting that you need to be careful of is that if an argument is a number with a leading minus sign it will be mistaken to be a command line option. To avoid this issue, specify the number without the minus sign and follow it with chs. Alternatively, you can embed the number in quotes but add a leading space. For example,
$ ec -x -30 dbmv
ec: -30 dbmv: unknown option.
$ ec -x 30 chs dbmv
10 mV
$ ec -x ' -30' dbmv
10 mV

DIAGNOSTICS

If an error occurs on a line, an error message is printed and the stack is restored to the values it had before the line was entered. So it is almost as if you never typed the line in at all. The exception being that any variables or modes that are set on the line before the error occurred are retained. For example,
0: 1KOhms =r
1 KOhms: 100MHz =freq 1pF = c
=: unrecognized
1 KOhms: stack
x: 1 KOhms
1 KOhms: vars
Rref: 50 Ohms
freq: 100MHz
r: 1 KOhms

The error occurred when trying to assign a value to c because a space was accidentally left between the equal sign and the variable name. Notice that 100MHz was saved to the variable freq, but the stack was restored to the state it had before the offending line was entered.

SEE ALSO

bc, dc

AUTHOR
Ken Kundert <ec@nurdletech.com>