HSPICE Compatibility Functions

The following functions are available, for compatibility with HSPICE.

These functions differ from other math functions in that they take multiple comma-separated arguments, Other math functions internally accept a single argument, but if there are multiple comma-separated terms, they will be collapsed into a single argument through evaluation of the comma operator

which yields a complex value. This will not be true in the functions listed below - the comma really means separate arguments in this case.a,b = (a + j*b)

The first group of functions are equivalent to the HSPICE Monte Carlo
functions that are called in `.param` lines in HSPICE. In
* WRspice*, these are regular math functions.

These functions will return mean values unless enabled. They are
enabled while in Monte Carlo analysis, or if the *random* variable
is set, either from the command line or from a `.options` line in
a circuit file.

`unif`(*nom*,*rvar*)

Uniform relative random value function.This returns a vector the same length as

*nom*, complex or real as*nom*. If the length of*rvar*is less than the length of*nom*,*rvar*is extended by replicating the highest index value of*rvar*.If we are not running Monte Carlo analysis, and the

*random*variable is not set, the return vector is the same as*nom*(no random values are generated). Otherwise the return vector contains uniformly distributed random values, each in the range [*nom*-*nom***rvar*,*nom*+*nom***rvar*] term-by-term.Below,

`random`is a pseudo-function that returns a random number between -1 and 1.- If
*nom*is complex and*var*is complex:

`out[i].real = nom[i].real*(1 + random()*rvar[i].real)`

`out[i].imag = nom[i].imag*(1 + random()*rvar[i].imag)` - If
*nom*is complex and*var*is real:

`out[i].real = nom[i].real*(1 + random()*rvar[i])`

`out[i].imag = nom[i].imag*(1 + random()*rvar[i])` - If
*nom*is real and*var*is complex:

`out[i] = nom[i].real*(1 + random()*rvar[i].real)` - If
*nom*is real and*var*is real:

`out[i] = nom[i]*(1 + random()*rvar[i])`

- If
`aunif`(*nom*,*var*)

Uniform absolute random value function.This returns a vector the same length as

*nom*, complex or real as*nom*. If the length of*var*is less than the length of*nom*,*var*is extended by replicating the highest index value of*var*.If we are not running Monte Carlo analysis, and the

*random*variable is not set, the return vector is the same as*nom*(no random values are generated). Otherwise The return vector contains uniformly distributed random values, each in the range [*nom*-*var*,*nom*+*var*] term-by-term.Below,

`random`is a pseudo-function that returns a random number between -1 and 1.- If
*nom*is complex and*var*is complex:

`out[i].real = nom[i].real + random()*var[i].real`

`out[i].imag = nom[i].imag + random()*var[i].imag` - If
*nom*is complex and*var*is real:

`out[i].real = nom[i].real + random()*var[i]`

`out[i].imag = nom[i].imag + random()*var[i]` - If
*nom*is real and*var*is complex:

`out[i] = nom[i].real + random()*var[i].real` - If
*nom*is real and*var*is real:

`out[i] = nom[i] + random()*var[i]`

- If
`gauss`(*nom*,*rvar*,*sigma*)

Gaussian relative random number generator.This returns a vector the same length as

*nom*, complex or real as*nom*. If the length of*rvar*is less than the length of*nom*,*rvar*is extended by replicating the highest index value of*rvar*. Only the zero'th (real) component of*sigma*is used.If fewer than three arguments are given, this reverts to the original

*WRspice*`gauss`function (now called`ogauss`).If we are not running Monte Carlo analysis, and the

*random*variable is not set, the return vector is the same as*nom*(no random values are generated). Otherwise the return vector contains gaussian-distributed random values. The (scalar)*sigma*value gives the specified sigma of the*rvar*data, generally 1 or 3.Below, the pseudo-function

`gauss`returns a gaussian random number with zero mean and unit standard deviation.- If
*nom*is complex and*var*is complex:

`out[i].real = nom[i].real*(1 + gauss()*rvar[i].real/sigma)`

`out[i].imag = nom[i].imag*(1 + gauss()*rvar[i].imag/sigma)` - If
*nom*is complex and*var*is real:

`out[i].real = nom[i].real*(1 + gauss()*rvar[i]/sigma)`

`out[i].imag = nom[i].imag*(1 + gauss()*rvar[i]/sigma)` - If
*nom*is real and*var*is complex:

`out[i] = nom[i].real*(1 + gauss()*rvar[i].real/sigma)` - If
*nom*is real and*var*is real:

`out[i] = nom[i]*(1 + gauss()*rvar[i]/sigma)`

- If
`agauss`(*nom*,*var*,*sigma*)

Gaussian absolute random number generator.This returns a vector the same length as

*nom*, complex or real as*nom*. If the length of*var*is less than the length of*nom*,*var*is extended by replicating the highest index value of*var*. Only the zero'th (real) component of*sigma*is used.If we are not running Monte Carlo analysis, and the

*random*variable is not set, the return vector is the same as*nom*(no random values are generated). Otherwise the return vector contains gaussian-distributed random values. The (scalar)*sigma*value gives the specified sigma of the var data, generally 1 or 3.Below, the pseudo-function

`gauss`returns a gaussian random number with zero mean and unit standard deviation.- If
*nom*is complex and*var*is complex:

`out[i].real = nom[i].real + gauss()*var[i].real/sigma`

`out[i].imag = nom[i].imag + gauss()*var[i].imag/sigma` - If
*nom*is complex and*var*is real:

`out[i].real = nom[i].real + gauss()*var[i]/sigma`

`out[i].imag = nom[i].imag + gauss()*var[i]/sigma` - If
*nom*is real and*var*is complex:

`out[i] = nom[i].real + gauss()*var[i].real/sigma` - If
*nom*is real and*var*is real:

`out[i] = nom[i] + gauss()*var[i]/sigma`

- If
`limit`(*nom*,*var*)

Random limit function.This returns a vector the same length as

*nom*, complex or real as*nom*. If the length of*var*is less than the length of*nom*,*var*is extended by replicating the highest index value of*var*.If we are not running Monte Carlo analysis, and the

*random*variable is not set, the return vector is the same as*nom*(no random values are generated). Otherwise the return vector contains either*nom*+*var*or*nom*-*var*determined randomly, term-by-term.- If
*nom*is complex and*var*is complex:

`out[i].real = nom[i].real +/- var[i].real`randomly

`out[i].imag = nom[i].imag +/- var[i].imag`randomly - If
*nom*is complex and*var*is real:

`out[i].real = nom[i].real +/- var[i]`randomly

`out[i].imag = nom[i].imag +/- var[i]`randomly - If
*nom*is real and*var*is complex:

`out[i] = nom[i].real +/- var[i].real`randomly - If
*nom*is real and*var*is real:

`out[i] = nom[i] +/- var[i]`randomly

- If

The remaining functions are for HSPICE compatibility, but are not exclusive to the HSPICE Monte Carlo analysis. These also have multiple arguments.

`pow`(*x*,*y*)

This returns a real or complex vector the same length as*x*. If the length of*y*is less than the length of*x*,*y*is extended by replicating the highest index value of*y*.This returns a vector containing

*x*^{y}computed using complex values, term-by-term, however if*y*is real, is is truncated to an integer value.- If
*x*is complex and*y*is complex:

`out =`*x*^{y}(same as ^ operator) - If
*x*is complex and*y*is real:

`out =`*x*^{(}*int*)*y*(same as ^ operator, but*y*is truncated to integer) - If
*x*is real and*y*is complex:

`out =`*x*^{y}(same as ^ operator) - If
*x*is real and*y*is real:

`out =`*x*^{(}*int*)*y*(same as ^ operator, but*y*is truncated to integer)

- If
`pwr`(*x*,*y*)

This returns a real vector the same length as*x*. If the length of*y*is less than the length of*x*,*y*is extended by replicating the highest index value of*y*.- If
*x*is complex and*y*is complex:

`out[i] =`(sign of`x[i].real`)(`mag(x[i])`^`y[i].real`) - If
*x*is complex and*y*is real:

`out[i] =`(sign of`x[i].real`)(`mag(x[i])`^`y[i]`) - If
*x*is real and*y*is complex:

`out[i] =`(sign of`x[i].real`)(`abs(x[i])`^`y[i].real`) - If
*x*is real and*y*is real:

`out[i] =`(sign of`x[i]`)(`abs(x[i])`^`y[i]`)

- If
`sign`(*x*,*y*)

This returns a vector the same length as*x*, complex or real as*x*. If the length of*y*is less than the length of*x*,*y*is extended by replicating the highest index value of*y*.- If
*x*is complex and*y*is complex:

`out[i].real =`(sign of`y[i].real`)`abs(x[i].real)`

`out[i].imag =`(sign of`y[i].imag`)`abs(x[i].imag)` - If
*x*is complex and*y*is real:

`out[i].real =`(sign of`y[i]`)`abs(x[i].real)`

`out[i].imag =`(sign of`y[i]`)`abs(x[i].imag)` - If
*x*is real and*y*is complex:

`out[i] =`(sign of`y[i].real`)`abs(x[i])` - If
*x*is real and*y*is real:

`out[i] =`(sign of`y[i]`)`abs(x[i])`

- If