@database "mathieeedoubbas"
@master "AMIDEV:NDK/Autodocs/mathieeedoubbas.doc"

@Node Main "mathieeedoubbas.doc"
@toc "Autodocs/AG/INDEX/Main"
    @{" IEEEDPAbs() " Link "IEEEDPAbs()"}
    @{" IEEEDPAdd() " Link "IEEEDPAdd()"}
    @{" IEEEDPCeil() " Link "IEEEDPCeil()"}
    @{" IEEEDPCmp() " Link "IEEEDPCmp()"}
    @{" IEEEDPDiv() " Link "IEEEDPDiv()"}
    @{" IEEEDPFix() " Link "IEEEDPFix()"}
    @{" IEEEDPFloor() " Link "IEEEDPFloor()"}
    @{" IEEEDPFlt() " Link "IEEEDPFlt()"}
    @{" IEEEDPMul() " Link "IEEEDPMul()"}
    @{" IEEEDPNeg() " Link "IEEEDPNeg()"}
    @{" IEEEDPSub() " Link "IEEEDPSub()"}
    @{" IEEEDPTst() " Link "IEEEDPTst()"}
@EndNode

@Node "IEEEDPAbs()" "mathieeedoubbas.library/IEEEDPAbs"

@{b}   NAME@{ub}
	IEEEDPAbs -- compute absolute value of IEEE double precision argument

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPAbs(  y  );
	d0/d1		  d0/d1

	double	x,y;

@{b}   FUNCTION@{ub}
	Take the absolute value of argument y and return it to caller.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	x -- IEEE double precision floating point value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
@EndNode

@Node "IEEEDPAdd()" "mathieeedoubbas.library/IEEEDPAdd"

@{b}   NAME@{ub}
	IEEEDPAdd -- add one double precision IEEE number to another

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPAdd(  y  ,  z  );
	d0/d1		  d0/d1 d2/d3

	double	x,y,z;

@{b}   FUNCTION@{ub}
	Compute x = y + z in IEEE double precision.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value
	z -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	x -- IEEE double precision floating point value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEEDPSub" Link "mathieeedoubbas/IEEEDPSub()"}
@EndNode

@Node "IEEEDPCeil()" "mathieeedoubbas.library/IEEEDPCeil"

@{b}   NAME@{ub}
	IEEEDPCeil -- compute Ceil function of IEEE double precision number

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPCeil(  y  );
	d0/d1		   d0/d1

	double	x,y;

@{b}   FUNCTION@{ub}
	Calculate the least integer greater than or equal to x and return it.
	This value may have more than 32 bits of significance.
	This identity is true.  Ceil(x) = -Floor(-x).

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	x -- IEEE double precision floating point value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEEDPFloor" Link "mathieeedoubbas/IEEEDPFloor()"}
@EndNode

@Node "IEEEDPCmp()" "mathieeedoubbas.library/IEEEDPCmp"

@{b}   NAME@{ub}
	IEEEDPCmp -- compare two double precision floating point numbers

@{b}   SYNOPSIS@{ub}
	  c   = IEEEDPCmp(  y  ,  z  );
	  d0		  d0/d1 d2/d3

	double	y,z;
	long	c;

@{b}   FUNCTION@{ub}
	Compare y with z. Set the condition codes for less, greater, or
	equal. Set return value c to -1 if y<z, or +1 if y>z, or 0 if
	y == z.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value
	z -- IEEE double precision floating point value

@{b}   RESULT@{ub}
       c = 1   cc = gt         for (y > z)
       c = 0   cc = eq         for (y == z)
       c = -1  cc = lt         for (y < z)

@{b}   BUGS@{ub}
	did not compare correctly if negative and the MSB of the
	mantissae were equal. fixed.

@{b}   SEE ALSO@{ub}
@EndNode

@Node "IEEEDPDiv()" "mathieeedoubbas.library/IEEEDPDiv"

@{b}   NAME@{ub}
	IEEEDPDiv -- divide one double precision IEEE by another

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPDiv(  y  ,  z  );
	d0/d1		  d0/d1 d2/d3

	double	x,y,z;

@{b}   FUNCTION@{ub}
	Compute x = y / z in IEEE double precision.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value
	z -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	x -- IEEE double precision floating point value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEEDPMul" Link "mathieeedoubbas/IEEEDPMul()"}
@EndNode

@Node "IEEEDPFix()" "mathieeedoubbas.library/IEEEDPFix"

@{b}   NAME@{ub}
	IEEEDPFix -- convert IEEE double float to integer

@{b}   SYNOPSIS@{ub}
	x   = IEEEDPFix(  y  );
	d0		d0/d1

	long	x;
	double	y;

@{b}   FUNCTION@{ub}
	Convert IEEE double precision argument to a 32 bit signed integer
	and return result.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	if no overflow occured then return
		x -- 32 bit signed integer
	if overflow return largest +- integer
		For round to zero

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEEDPFlt" Link "mathieeedoubbas/IEEEDPFlt()"}
@EndNode

@Node "IEEEDPFloor()" "mathieeedoubbas.library/IEEEDPFloor"

@{b}   NAME@{ub}
	IEEEDPFloor -- compute Floor function of IEEE double precision number

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPFloor(  y  );
	d0/d1		    d0/d1

	double	x,y;

@{b}   FUNCTION@{ub}
	Calculate the largest integer less than or equal to x and return it.
	This value may have more than 32 bits of significance.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	x -- IEEE double precision floating point value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEEDPCeil" Link "mathieeedoubbas/IEEEDPCeil()"}
@EndNode

@Node "IEEEDPFlt()" "mathieeedoubbas.library/IEEEDPFlt"

@{b}   NAME@{ub}
	IEEEDPFlt -- convert integer to IEEE double precision number

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPFlt(  y  );
	d0/d1		   d0

	double	x;
	long	y;

@{b}   FUNCTION@{ub}
	Convert a signed 32 bit value to a double precision IEEE value
	and return it in d0/d1. No exceptions can occur with this
	function.

@{b}   INPUTS@{ub}
	y -- 32 bit integer in d0

@{b}   RESULT@{ub}
	x is a 64 bit double precision IEEE value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEEDPFix" Link "mathieeedoubbas/IEEEDPFix()"}
@EndNode

@Node "IEEEDPMul()" "mathieeedoubbas.library/IEEEDPMul"

@{b}   NAME@{ub}
	IEEEDPMul -- multiply one double precision IEEE number by another

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPMul(  y  ,  z  );
	d0/d1		  d0/d1 d2/d3

	double	x,y,z;

@{b}   FUNCTION@{ub}
	Compute x = y * z in IEEE double precision.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value
	z -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	x -- IEEE double precision floating point value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEEDPDiv" Link "mathieeedoubbas/IEEEDPDiv()"}
@EndNode

@Node "IEEEDPNeg()" "mathieeedoubbas.library/IEEEDPNeg"

@{b}   NAME@{ub}
	IEEEDPNeg -- compute negative value of IEEE double precision number

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPNeg(  y  );
	d0/d1		  d0/d1

	double	x,y;

@{b}   FUNCTION@{ub}
	Invert the sign of argument y and return it to caller.

@{b}   INPUTS@{ub}
	y - IEEE double precision floating point value

@{b}   RESULT@{ub}
	x - IEEE double precision floating point value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
@EndNode

@Node "IEEEDPSub()" "mathieeedoubbas.library/IEEEDPSub"

@{b}   NAME@{ub}
	IEEEDPSub -- subtract one double precision IEEE number from another

@{b}   SYNOPSIS@{ub}
	  x   = IEEEDPSub(  y  ,  z  );
	d0/d1		  d0/d1 d2/d3

	double	x,y,z;

@{b}   FUNCTION@{ub}
	Compute x = y - z in IEEE double precision.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value
	z -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	x -- IEEE double precision floating point value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEEDPAdd" Link "mathieeedoubbas/IEEEDPAdd()"}
@EndNode

@Node "IEEEDPTst()" "mathieeedoubbas.library/IEEEDPTst"

@{b}   NAME@{ub}
	IEEEDPTst -- compare IEEE double precision value to 0.0

@{b}   SYNOPSIS@{ub}
	  c   = IEEEDPTst(  y  );
	  d0		  d0/d1

	double	y;
	long	c;

@{b}   FUNCTION@{ub}
	Compare y to 0.0, set the condition codes for less than, greater
	than, or equal to 0.0.  Set the return value c to -1 if less than,
	to +1 if greater than, or 0 if equal to 0.0.

@{b}   INPUTS@{ub}
	y -- IEEE double precision floating point value

@{b}   RESULT@{ub}
	c = 1	cc = gt		for (y > 0.0)
	c = 0	cc = eq		for (y == 0.0)
	c = -1  cc = lt		for (y < 0.0)

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
@EndNode