PFE 0.33.71

Homepage
SourceForge
Download
Documentation
-Overview
-The PFE Manual
old manual / (book)
-ChangeLog
-Authors
-License (LGPL)
-Wordsets / (book)
-Functions .. (book)
-Dp of ANS Forth
-The 4thTutor
-Forthprimer.pdf
- Old Wordsets
- Old Words List
Forth Links
* Forth Repository
* Taygeta Compilation
* TinyBoot FirmWare
* FiCL, Free Forth
* Research Vienna
* Research Bournemouth
* zForth WebRing
Other Links
* Tektronix/MPT
* Forth Org. (FIG)
* Forth Inc.
* MPE Ltd. Forths
* SF Win32Forth
* PD Win32Forth
* Neil Bawd

generated
(C) Guido U. Draheim
guidod@gmx.de

## Complex

> floating point

`R2P1``` => `"EXTENSIONS"`

  (no description)

  primitive code = [r2p1]

`T2P1``` => `"EXTENSIONS"`

  (no description)

  primitive code = [t2p1]

`LAMBDA/EPSILON``` => `"EXTENSIONS"`

  (no description)

  primitive code = [lambda_slash_epsilon]

`Z@``( addr -- f: z )``` => `"EXTENSIONS"`

  primitive code = [p4_z_fetch]

`Z!``( addr f: z -- )``` => `"EXTENSIONS"`

  primitive code = [p4_z_store]

`X@``( zaddr -- f: x )``` => `"EXTENSIONS"`

  primitive code = [p4_x_fetch]

`X!``( zaddr f: x -- )``` => `"EXTENSIONS"`

  primitive code = [p4_x_store]

`Y@``( zaddr -- f: y )``` => `"EXTENSIONS"`

  primitive code = [p4_y_fetch]

`Y!``( zaddr f: x -- )``` => `"EXTENSIONS"`

  primitive code = [p4_y_store]

`Z.``(f: z -- )``` => `"EXTENSIONS"`

  Emit the complex number, including the sign of zero when `signbit()` is available.

  primitive code = [p4_z_dot]

`ZS.``(f: z -- )``` => `"EXTENSIONS"`

  Emit the complex number in scientific notation, including the sign of zero when `signbit()` is available.

  primitive code = [p4_z_s_dot]

`REAL``(f: x y -- x )``` => `"EXTENSIONS"`

  primitive code = [p4_real]

`IMAG``(f: x y -- y )``` => `"EXTENSIONS"`

  primitive code = [p4_imag]

`CONJG``(f: x y -- x -y )``` => `"EXTENSIONS"`

  primitive code = [p4_conjg]

`ZDROP``(f: z -- )``` => `"EXTENSIONS"`

  primitive code = [p4_z_drop]

`ZDUP``(f: z -- z z )``` => `"EXTENSIONS"`

  primitive code = [p4_z_dup]

`ZSWAP``(f: z1 z2 -- z2 z1 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_swap]

`ZOVER``(f: z1 z2 -- z1 z2 z1 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_over]

`ZNIP``(f: z1 z2 -- z2 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_nip]

`ZTUCK``(f: z1 z2 -- z2 z1 z2 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_tuck]

`ZROT``(f: z1 z2 z3 -- z2 z3 z1 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_rot]

`-ZROT``(f: z1 z2 z3 -- z3 z1 z2 )``` => `"EXTENSIONS"`

  primitive code = [p4_minus_z_rot]

`Z+``(f: z1 z2 -- z1+z2 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_plus]

`Z-``(f: z1 z2 -- z1-z2 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_minus]

`Z*``(f: x y u v -- x*u-y*v x*v+y*u )``` => `"EXTENSIONS"`

  Uses the algorithm followed by JVN: (x+iy)*(u+iv) = [(x+y)*u - y*(u+v)] + i[(x+y)*u + x*(v-u)] Requires 3 multiplications and 5 additions.

  primitive code = [p4_z_star]

`Z/``(f: u+iv z -- u/z+iv/z )``` => `"EXTENSIONS"`

  Kahan-like algorithm *without* due attention to spurious over/underflows and zeros and infinities.

  primitive code = [p4_z_slash]

`ZNEGATE``(f: z -- -z )``` => `"EXTENSIONS"`

  primitive code = [p4_z_negate]

`Z2*``(f: z -- z*2 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_two_star]

`Z2/``(f: z -- z/2 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_two_slash]

`I*``(f: x y -- -y x )``` => `"EXTENSIONS"`

  primitive code = [p4_i_star]

`-I*``(f: x y -- y -x )``` => `"EXTENSIONS"`

  primitive code = [p4_minus_i_star]

`1/Z``(f: z -- 1/z )``` => `"EXTENSIONS"`

  Kahan algorithm *without* due attention to spurious over/underflows and zeros and infinities.

  primitive code = [p4_one_slash_z]

`Z^2``(f: z -- z^2 )``` => `"EXTENSIONS"`

  Kahan algorithm without removal of any spurious NaN created by overflow. It deliberately uses (x-y)(x+y) instead of x^2-y^2 for the real part.

  primitive code = [p4_z_hat_two]

`|Z|^2``(f: x y -- |z|^2 )``` => `"EXTENSIONS"`

  primitive code = [p4_z_abs_hat_two]

`Z^N``( n f: z -- z^n )``` => `"EXTENSIONS"`

  primitive code = [p4_z_hat_n]

`X+``(f: z a -- x+a y )``` => `"EXTENSIONS"`

  primitive code = [p4_x_plus]

`X-``(f: z a -- x-a y )``` => `"EXTENSIONS"`

  primitive code = [p4_x_minus]

`Y+``(f: z a -- x y+a )``` => `"EXTENSIONS"`

  primitive code = [p4_y_plus]

`Y-``(f: z a -- x y-a )``` => `"EXTENSIONS"`

  primitive code = [p4_y_minus]

`Z*F``(f: x y f -- x*f y*f )``` => `"EXTENSIONS"`

  primitive code = [p4_z_star_f]

`Z/F``(f: x y f -- x/f y/f )``` => `"EXTENSIONS"`

  primitive code = [p4_z_slash_f]

`F*Z``(f: f x y -- f*x f*y )``` => `"EXTENSIONS"`

  primitive code = [p4_f_star_z]

`F/Z``(f: f z -- f/z )``` => `"EXTENSIONS"`

  Kahan algorithm *without* due attention to spurious over/underflows and zeros and infinities.

  primitive code = [p4_f_slash_z]

`Z*I*F``(f: z f -- z*if )``` => `"EXTENSIONS"`

  primitive code = [p4_z_star_i_star_f]

`-I*Z/F``(f: z f -- z/[if] )``` => `"EXTENSIONS"`

  primitive code = [p4_minus_i_star_z_slash_f]

`I*F*Z``(f: f z -- if*z )``` => `"EXTENSIONS"`

  primitive code = [p4_i_star_f_star_z]

`I*F/Z``(f: f z -- [0+if]/z )``` => `"EXTENSIONS"`

  Kahan algorithm *without* due attention to spurious over/underflows and zeros and infinities.

  primitive code = [p4_i_star_f_slash_z]

`Z*>REAL``(f: z1 z2 -- Re[z1*z2] )``` => `"EXTENSIONS"`

  Compute the real part of the complex product without computing the imaginary part. Recommended by Kahan to avoid gratuitous overflow or underflow signals from the unnecessary part.

  primitive code = [p4_z_star_to_real]

`Z*>IMAG``(f: z1 z2 -- Im[z1*z2] )``` => `"EXTENSIONS"`

  Compute the imaginary part of the complex product without computing the real part.

  primitive code = [p4_z_star_to_imag]

`|Z|``(f: x y -- |z| )``` => `"EXTENSIONS"`

  primitive code = [p4_z_abs]

`ZBOX``(f: z -- box[z] )``` => `"EXTENSIONS"`

  Defined *only* for zero and infinite arguments. This difffers from Kahan's `CBOX` [p. 198] by conserving signs when only one of x or y is infinite, consistent with the other cases, and with its use in his `ARG` [p. 199].

  primitive code = [p4_z_box]

`ARG``(f: z -- principal.arg[z] )``` => `"EXTENSIONS"`

  primitive code = [p4_arg]

`>POLAR``(f: x y -- r theta )``` => `"EXTENSIONS"`

  Convert the complex number z to its polar representation, where theta is the principal argument.

  primitive code = [p4_to_polar]

`POLAR>``(f: r theta -- x y )``` => `"EXTENSIONS"`

  primitive code = [p4_polar_from]

`ZSSQS``(f: z -- rho s: k )``` => `"EXTENSIONS"`

  Compute rho = |(x+iy)/2^k|^2, scaled to avoid overflow or underflow, and leave the scaling integer k. Kahan, p. 200.

  primitive code = [p4_z_ssqs]

`ZSQRT``(f: z -- sqrt[z] )``` => `"EXTENSIONS"`

  Compute the principal branch of the square root, with Re sqrt[z] >= 0. Kahan, p. 201.

  primitive code = [p4_z_sqrt]

`ZLN``(f: z -- ln|z|+i*theta )``` => `"EXTENSIONS"`

  Compute the principal branch of the complex natural logarithm. The angle theta is the principal argument. This code uses Kahan's algorithm for the scaled logarithm `CLOGS(z,J)` = ln(z*2^J), with J=0 and blind choices of the threshholds T0, T1, and T2. Namely, T0 = 1/sqrt(2), T1 = 5/4, and T2 = 3;

  primitive code = [p4_z_ln]

`ZEXP``(f: z -- exp[z] )``` => `"EXTENSIONS"`

  primitive code = [p4_z_exp]

`Z^``(f: x y u v -- [x+iy]^[u+iv] )``` => `"EXTENSIONS"`

  Compute in terms of the principal argument of x+iy.

  primitive code = [p4_z_hat]

`ZCOSH``(f: z -- cosh[z] )``` => `"EXTENSIONS"`

  primitive code = [p4_z_cosh]

`ZSINH``(f: z -- sinh[z] )``` => `"EXTENSIONS"`

  primitive code = [p4_z_sinh]

`ZTANH``(f: z -- tanh[z] )``` => `"EXTENSIONS"`

  Kahan, p. 204, including his divide by zero signal suppression for infinite values of `tan()`. To quote the very informative "=>'man math'" on our Darwin system about IEEE 754: "Divide-by-Zero is signaled only when a function takes exactly infinite values at finite operands."

  primitive code = [p4_z_tanh]

`ZCOTH``(f: z -- 1/tanh[z] )``` => `"EXTENSIONS"`

  primitive code = [p4_z_coth]

`ZCOS``(f: z -- cosh[i*z] )``` => `"EXTENSIONS"`

  primitive code = [p4_z_cos]

`ZSIN``(f: z -- -i*sinh[i*z] )``` => `"EXTENSIONS"`

  primitive code = [p4_z_sin]

`ZTAN``(f: z -- -i*tanh[i*z] )``` => `"EXTENSIONS"`

  primitive code = [p4_z_tan]

`ZCOT``(f: z -- -i*coth[-i*z] )``` => `"EXTENSIONS"`

  primitive code = [p4_z_cot]

`ZACOS``(f: z -- u+iv=acos[z] )``` => `"EXTENSIONS"`

  Kahan, p.202.

  primitive code = [p4_z_acos]

`ZACOSH``(f: z -- u+iv=acosh[z] )``` => `"EXTENSIONS"`

  Kahan, p.203.

  primitive code = [p4_z_acosh]

`ZASIN``(f: z -- u+iv=asin[z] )``` => `"EXTENSIONS"`

  Kahan, p.203.

  primitive code = [p4_z_asin]

`ZASINH``(f: z -- -i*asin[i*z] )``` => `"EXTENSIONS"`

  Kahan, p. 203, couth.

  primitive code = [p4_z_asinh]

`ZATANH``(f: z -- u+iv=atanh[z] )``` => `"EXTENSIONS"`

  Kahan, p. 203.

  primitive code = [p4_z_atanh]

`ZATAN``(f: z -- -i*atanh[i*z] )``` => `"EXTENSIONS"`

  Kahan, p. 204, couth.

  primitive code = [p4_z_atan]

`ZLITERAL``` => `"EXTENSIONS"`

  (no description)

  compiling word = [p4_z_literal]