func:
  sin - evaluate the sine function on each element of the dataset
real:
  ox = Math.sin(ix);
complex:
  ox = Math.sin(ix)*Math.cosh(iy);
  oy = Math.cos(ix)*Math.sinh(iy);

func:
  cos - evaluate the cosine function on each element of the dataset
real:
  ox = Math.cos(ix);
complex:
  ox = Math.cos(ix)*Math.cosh(iy);
  oy = -Math.sin(ix)*Math.sinh(iy);

func:
  tan - evaluate the tangent function on each element of the dataset
real:
  ox = Math.tan(ix);
complex:
  x = 2.*ix;
  y = 2.*iy;
  tf = 1./(Math.cos(x)+Math.cosh(y));
  ox = tf*Math.sin(x);
  oy = tf*Math.sinh(y);

func:
  arcsin - evaluate the inverse sine function on each element of the dataset
real:
  ox = Math.asin(ix);
complex:
  tz = new Complex(ix, iy).asin();
  ox = tz.getReal();
  oy = tz.getImaginary();

func:
  arccos - evaluate the inverse cosine function on each element of the dataset
real:
  ox = Math.acos(ix);
complex:
  tz = new Complex(ix, iy).acos();
  ox = tz.getReal();
  oy = tz.getImaginary();

func:
  arctan - evaluate the inverse tangent function on each element of the dataset
real:
  ox = Math.atan(ix);
complex:
  tz = new Complex(ix, iy).atan();
  ox = tz.getReal();
  oy = tz.getImaginary();

func:
  sinh - evaluate the hyperbolic sine function on each element of the dataset
real:
  ox = Math.sinh(ix);
complex:
  ox = Math.sinh(ix)*Math.cos(iy);
  oy = Math.cosh(ix)*Math.sin(iy);

func:
  cosh - evaluate the hyperbolic cosine function on each element of the dataset
real:
  ox = Math.cosh(ix);
complex:
  ox = Math.cosh(ix)*Math.cos(iy);
  oy = Math.sinh(ix)*Math.sin(iy);

func:
  tanh - evaluate the tangent hyperbolic function on each element of the dataset
real:
  ox = Math.tanh(ix);
complex:
  tx = 2.*ix;
  ty = 2.*iy;
  tf = 1./(Math.cos(tx)+Math.cosh(ty));
  ox = tf*Math.sinh(tx);
  oy = tf*Math.sin(ty);

func:
  arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset
real:
  ox = Math.log(ix + Math.sqrt(ix*ix + 1));
complex:
  tz = new Complex(-iy, ix).asin();
  ox = tz.getImaginary();
  oy = -tz.getReal();

func:
  arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset
real:
  ox = Math.log(ix + Math.sqrt(ix*ix - 1));
complex:
  tz = new Complex(-iy, ix).acos();
  ox = tz.getImaginary();
  oy = -tz.getReal();

func:
  arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset
real:
  ox = 0.5*Math.log((1 + ix)/(1 - ix));
complex:
  tz = new Complex(-iy, ix).atan();
  ox = tz.getImaginary();
  oy = -tz.getReal();

func:
  log - evaluate the logarithm function on each element of the dataset
real:
  ox = Math.log(ix);
complex:
  ox = Math.log(Math.hypot(ix, iy));
  oy = Math.atan2(iy, ix);

func:
  log2 - evaluate the logarithm function on each element of the dataset
real:
  ox = Math.log(ix)/Math.log(2.);
complex:
  ox = Math.log(Math.hypot(ix, iy))/Math.log(2.);
  oy = Math.atan2(iy, ix);

func:
  log10 - evaluate the logarithm function on each element of the dataset
real:
  ox = Math.log10(ix);
complex:
  ox = Math.log10(Math.hypot(ix, iy));
  oy = Math.atan2(iy, ix);

func:
  log1p - evaluate the logarithm function of 1 plus on each element of the dataset
real:
  ox = Math.log1p(ix);
complex:
  ox = 0.5*Math.log1p(ix*ix + 2.*ix + iy*iy);
  oy = Math.atan2(iy, ix+1);

func:
  exp - evaluate the exponential function on each element of the dataset
real:
  ox = Math.exp(ix);
complex:
  tf = Math.exp(ix);
  ox = tf*Math.cos(iy);
  oy = tf*Math.sin(iy);

func:
  expm1 - evaluate the exponential function - 1 on each element of the dataset
real:
  ox = Math.expm1(ix);
complex:
  tf = Math.expm1(ix);
  ox = tf*Math.cos(iy);
  oy = tf*Math.sin(iy);

func:
  sqrt - evaluate the square root function on each element of the dataset
real:
  ox = Math.sqrt(ix);
complex:
  tz = new Complex(ix, iy).sqrt();
  ox = tz.getReal();
  oy = tz.getImaginary();

func:
  cbrt - evaluate the cube root function on each element of the dataset
real:
  ox = Math.cbrt(ix);
complex:
  tz = new Complex(ix, iy).pow(new Complex(1./3.,0));
  ox = tz.getReal();
  oy = tz.getImaginary();

func:
  square - square each element
integer:
  ox = ix*ix;
real:
  ox = ix*ix;
complex:
  ox = ix*ix - iy*iy;
  oy = 2.*ix*iy;

func:
  floor - evaluate the floor function on each element of the dataset
integer:
  ox = ix;
real:
  ox = Math.floor(ix);
complex:
  ox = Math.floor(ix);
  oy = Math.floor(iy);

func:
  ceil - evaluate the ceiling function on each element of the dataset
integer:
  ox = ix;
real:
  ox = Math.ceil(ix);
complex:
  ox = Math.ceil(ix);
  oy = Math.ceil(iy);

func:
  rint - round each element of the dataset
integer:
  ox = ix;
real:
  ox = Math.rint(ix);
complex:
  ox = Math.rint(ix);
  oy = Math.rint(iy);

func:
  toDegrees - convert to degrees
real:
  ox = Math.toDegrees(ix);
complex:
  ox = Math.toDegrees(ix);
  oy = Math.toDegrees(iy);

func:
  toRadians - convert to radians
real:
  ox = Math.toRadians(ix);
complex:
  ox = Math.toRadians(ix);
  oy = Math.toRadians(iy);

func:
  signum - sign of each element
integer:
  ox = ix > 0 ? 1 : (ix < 0 ? -1 : 0);
real:
  ox = Math.signum(ix);
complex:
  ox = Math.signum(ix);
  oy = Math.signum(iy);

func:
  abs - absolute value of each element
integer:
  ox = Math.abs(ix);
real:
  ox = Math.abs(ix);
complex: real
  ox = Math.hypot(ix, iy);

func:
  negative - negative value of each element
integer:
  ox = -ix;
real:
  ox = -ix;
complex:
  ox = -ix;
  oy = -iy;

func: 2
  clip - clip elements to limits
integer:
  if (ix < pax)
  	ox = pax;
  else if (ix > pbx)
  	ox = pbx;
  else
  	ox = ix;
real:
  if (Double.isNaN(ix))
  	ox = (pax+pbx)/2.;
  else if (ix < pax)
  	ox = pax;
  else if (ix > pbx)
  	ox = pbx;
  else
  	ox = ix;
