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

@Node Main "mathieeesingbas.doc"
@toc "Autodocs/AG/INDEX/Main"
    @{" IEEESPAbs() " Link "IEEESPAbs()"}
    @{" IEEESPAdd() " Link "IEEESPAdd()"}
    @{" IEEESPCeil() " Link "IEEESPCeil()"}
    @{" IEEESPCmp() " Link "IEEESPCmp()"}
    @{" IEEESPDiv() " Link "IEEESPDiv()"}
    @{" IEEESPFix() " Link "IEEESPFix()"}
    @{" IEEESPFloor() " Link "IEEESPFloor()"}
    @{" IEEESPFlt() " Link "IEEESPFlt()"}
    @{" IEEESPMul() " Link "IEEESPMul()"}
    @{" IEEESPNeg() " Link "IEEESPNeg()"}
    @{" IEEESPSub() " Link "IEEESPSub()"}
    @{" IEEESPTst() " Link "IEEESPTst()"}
@EndNode

@Node "IEEESPAbs()" "mathieeesingbas.library/IEEESPAbs"

@{b}   NAME@{ub}
	IEEESPAbs -- compute absolute value of IEEE single precision argument

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPAbs(  y  );
	 d0		    d0

	float	x,y;

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

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

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

@{b}   BUGS@{ub}

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

@Node "IEEESPAdd()" "mathieeesingbas.library/IEEESPAdd"

@{b}   NAME@{ub}
	IEEESPAdd -- add one single precision IEEE number to another

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPAdd(  y  ,  z  );
	 d0		   d0     d1

	float	x,y,z;

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

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

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

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEESPSub" Link "mathieeesingbas/IEEESPSub()"}
@EndNode

@Node "IEEESPCeil()" "mathieeesingbas.library/IEEESPCeil"

@{b}   NAME@{ub}
	IEEESPCeil -- compute Ceil function of IEEE single precision number

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPCeil(  y  );
	 d0		     d0

	float	x,y;

@{b}   FUNCTION@{ub}
	Calculate the least integer greater than or equal to x and return it.
	This identity is true.  Ceil(x) = -Floor(-x).

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

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

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEESPFloor" Link "mathieeesingbas/IEEESPFloor()"}
@EndNode

@Node "IEEESPCmp()" "mathieeesingbas.library/IEEESPCmp"

@{b}   NAME@{ub}
	IEEESPCmp -- compare two single precision floating point numbers

@{b}   SYNOPSIS@{ub}
	  c   = IEEESPCmp(  y  ,  z  );
	  d0		    d0   d1

	float	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 single precision floating point value
	z -- IEEE single 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}

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

@Node "IEEESPDiv()" "mathieeesingbas.library/IEEESPDiv"

@{b}   NAME@{ub}
	IEEESPDiv -- divide one single precision IEEE by another

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPDiv(  y  ,  z  );
	 d0		   d0    d1

	float	x,y,z;

@{b}   FUNCTION@{ub}
	Compute x = y / z in IEEE single precision.
	Note that the Motorola fast floating point Div routine reverses
	the order of the arguments for the C interface, although the
	dividend is still in d0 and the divisor is in d1.

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

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

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEESPMul" Link "mathieeesingbas/IEEESPMul()"}
@EndNode

@Node "IEEESPFix()" "mathieeesingbas.library/IEEESPFix"

@{b}   NAME@{ub}
	IEEESPFix -- convert IEEE single float to integer

@{b}   SYNOPSIS@{ub}
	x   = IEEESPFix(  y  );
	d0		 d0

	long	x;
	float	y;

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

@{b}   INPUTS@{ub}
	y -- IEEE single 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}
	@{"IEEESPFlt" Link "mathieeesingbas/IEEESPFlt()"}
@EndNode

@Node "IEEESPFloor()" "mathieeesingbas.library/IEEESPFloor"

@{b}   NAME@{ub}
	IEEESPFloor -- compute Floor function of IEEE single precision number

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPFloor(  y  );
	  d0		      d0

	float	x,y;

@{b}   FUNCTION@{ub}
	Calculate the largest integer less than or equal to x and return it.

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

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

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEESPCeil" Link "mathieeesingbas/IEEESPCeil()"}
@EndNode

@Node "IEEESPFlt()" "mathieeesingbas.library/IEEESPFlt"

@{b}   NAME@{ub}
	IEEESPFlt -- convert integer to IEEE single precision number

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPFlt(  y  );
	 d0		   d0

	float	x;
	long	y;

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

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

@{b}   RESULT@{ub}
	x is a 32 bit single precision IEEE value

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEESPFix" Link "mathieeesingbas/IEEESPFix()"}
@EndNode

@Node "IEEESPMul()" "mathieeesingbas.library/IEEESPMul"

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

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPMul(  y  ,  z  );
	 d0		   d0    d1

	float	x,y,z;

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

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

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

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEESPDiv" Link "mathieeesingbas/IEEESPDiv()"}
@EndNode

@Node "IEEESPNeg()" "mathieeesingbas.library/IEEESPNeg"

@{b}   NAME@{ub}
	IEEESPNeg -- compute negative value of IEEE single precision number

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPNeg(  y  );
	  d0		   d0

	float	x,y;

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

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

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

@{b}   BUGS@{ub}

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

@Node "IEEESPSub()" "mathieeesingbas.library/IEEESPSub"

@{b}   NAME@{ub}
	IEEESPSub -- subtract one single precision IEEE number from another

@{b}   SYNOPSIS@{ub}
	  x   = IEEESPSub(  y  ,  z  );
	 d0		   d0     d1

	float	x,y,z;

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

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

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

@{b}   BUGS@{ub}

@{b}   SEE ALSO@{ub}
	@{"IEEESPAdd" Link "mathieeesingbas/IEEESPAdd()"}
@EndNode

@Node "IEEESPTst()" "mathieeesingbas.library/IEEESPTst"

@{b}   NAME@{ub}
	IEEESPTst -- compare IEEE single precision value to 0.0

@{b}   SYNOPSIS@{ub}
	  c   = IEEESPTst(  y  );
	  d0		    d0

	float	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 single 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