Integer Math

	{
	   quad num;
	   _abs_q(_mov_ql(num, 0xFFFFFFFF));/* num1 = 1 */
	}

	#include <inline.h>
	{
	   quad num;
	   ...
	   lea di,num	/* DI = offset of num */
	   mov ax,0xFFFF
	   mov dx,0xFFFF/* DX:AX = 0xFFFFFFFF */
	   mov_ql();	/* num = 0xFFFFFFFF */
	   abs_q();	/* num = 1 */
	   ...
	}

See also

_neg_q

_add_qi

Descrip

Adds an int into a quad.

Syntax

#include <imath.h>
quadptr _add_qi(quad num1, int num2);

Returns

A pointer to num1.
num1 quad result (num1 + num2)

Notes

This function adds the int value in num2 into the quad value in num1. A pointer is returned to num1.

	{
	   quad num1;
	   ...
	   _mov_qi(num1,65000);
	   _add_qi(num1,65000);    /* num1 += num2 */
	   ...
	}

	{
	   quad num1;
	   ...
	   mov ax,65000
	   lea di,num1	    /* DI = offset of num1 */
	   mov_qi();	/* set num1 value /
	   add_qi();	/* num1 += num2 */
	    jnooverflow/* jump to label if overflow */
	   ...
	overflow:
	   ...
	}

_add_ql

Descrip

Adds a long into a quad.

Syntax

#include <imath.h>
quadptr _add_ql(quad num1, long num2);

Returns

A pointer to num1.
num1 quad result (num1 + num2)

Notes

This function adds the long value in num2 into the quad value in num1. A pointer to the quad result in num1 is returned.

	{
	   long num2 = 1000;
	   quad num1;
	   quadptr num3;
	   _mov_ql(num1, 4000000000);/* set quad value */
	   num3 = _add_ql(num1, num2);/* quad + long */
	...
	}

	#include <inline.h>
	{
	   long num2 = 2000000000;
	   quad num1;
	   ... 
	   lea di,num1	      /* DI = offset of num1 */
	   mov dx,word ptr num2+2
	   mov ax,word ptr num2  /* DX;AX = num2 */
	   mov_ql();	  /* set quad value */
	   add_ql();	  /* num1++ */
	    jno       a_ql_100  /* jump to label if overflow */
	   ... 
	a_ql_100:
	   ... 
	}

_add_qq

Descrip

Adds two quad values.

Syntax

#include <imath.h>
quadptr _add_qq(quad num1, quad num2);

Returns

A pointer to num1.
num1 quad result (num1 + num2)

Notes

This function adds the quad value in num2 to num1. A pointer is returned to num1.

This function works on both quad and uquad values. Therefore, it may be used interchangeably with _add_uqq (_add_uqq and _add_qq are two different names for the same function).

	{
	   quad num1, num2;
	   _mov_ql(num1, 1999999999);
	   _mov_ql(num2, 1234567890);
	   _add_qq(num1, num2);/* num1 += num2 */
	}

	#include <inline.h>
	{
	   quad num1, num2;
	   long num_a = 1999999999, num_b = 1234567890;
	   ...
	         leadi,num1	    	  /* DI = offset of num1 */
	   lea si,num2	    	  /* SI = offset of num2 */
	   mov ax,word ptr num_a
	   mov dx,word ptr num_a+2/* DX;AX = 1999999999 */
	   mov_ql();	    /* set num1 value */
	   mov ax,word ptr num_b
	   mov ax,word ptr num_b+2/* DX;AX = 1234567890 */
	   xchgdi,si	    /* DI = offset of num2 */
	   mov_ql();	    /* set num2 value */
	   xchgdi,si	    /* DI = offset of num1 */
	   add_qq();	    /* num1 += num2 */
	    jnca_qq_100                       
	   ... 	 	    /* overflow occurred */
	a_qq_100:
	   ... 
	}

_add_uqi

Descrip

Adds an unsigned int into a uquad.

Syntax

#include <imath.h>
quadptr _add_uqi(uquad num1, unsigned int num2);

Returns

A pointer to num1.
num1 uquad result (num1 + num2)

Notes

This function adds the unsigned int num2 into the uquad num1. A pointer to num1 is returned.

	{
	   unsigned int num2;
	   uquad num1;
	   _add_uqi(num1,num2);/* num1 += num2 */
	   ...
	}

	#include <inline.h>
	{
	   unsigned int num2;
	   uquad num1;
	   ... 
	   lea di,num1	    /* DI = offset of num1 */
	   mov ax,num2	    /* AX = num2 */
	   add_uqi();	/* num1 += num2 */
	    jnca_uqi_100/* check for overflow */
	   ... 	 	/* unsigned overflow occurred */
	a_uqi_100:
	   ...
	}

_add_uql

Descrip

Adds an unsigned long into a uquad.

Syntax

#include <imath.h>
quadptr _add_uql(uquad num1, unsigned long num2);

Returns

A pointer to num1.
num1 uquad result (num1 + num2)

Notes

This function adds the unsigned long value in num2 into the uquad value in num1. A pointer to num1 is returned.

	{
	   unsigned long num2;
	   uquad num1;
	   _add_uql(num1,num2);/* num1 += num2 */
	}

	#include <inline.h>
	{
	   unsigned long num2;
	   uquad num1;
	   ...
	   lea di,num1	    	  /* DI = offset of num1 */
	   mov ax,word ptr num2	  	 
	   mov dx,word ptr num2+2/* DX:AX = num2 */
	   add_uql();	    /* num += num2 */
	    jnca_uql_100
	   ... 	 	/* unsigned overflow occurred */
	a_uql_100:
	   ...
	}

_add_uqq

Descrip

Adds two uquad values.

Syntax

#include <imath.h>
quadptr _add_uqq(uquad num1, uquad num2);

Returns

A pointer to num1.
num1 uquad result (num1 + num2)

Notes

This function adds num2 to num1. A pointer is returned to num1.

This function works on both quad and uquad values. Therefore, it may be used interchangeably with _add_qq (_add_uqq and _add_qq are two different names for the same function).

	{
	   uquad num1, num2;
	 
	   _mov_uqi(num1,1000);
	   _mov_uqi(num2,10000);
	   _add_uqq(num1, num2);/* num1 += num2 */
	}

	#include <inline.h>
	{
	   uquad num1, num2;
	   ...
	   lea di,num1	    /* DI = offset of num1 */
	   lea si,num2	    /* SI = offset of num2 */
	   xor ax,ax
	   mov dx,0xFFFF/* DX;AX = 0xFFFF0000 */
	   mov_uql();	/* set num1 value */
	   xchgdi,si	/* DI = offset of num2 */
	   mov_uql();	/* set num2 value */
	   xchgdi,si	/* DI = offset of num1 */
	   add_uqq();	/* num1 = num1 + num2 */
	    jnca_uqq_100/* if overflow jump to label */
	   ... 	 	    	  
	a_uqq_100:
	   ...
	}

_cmp_qi

Descrip

Compares a quad against an int.

Syntax

#include <imath.h>
int _cmp_qi(quad num1, int num2);

Returns

-1 if num1 is less than num2.

0 if num1 is equal to num2.

1 if num1 is greater than num2.

Notes

This function compares the quad value in num1 against the int value in num2. The return value reflects the result of the comparison.

	{
	   int num2 = 65535;
	   quad num1;

	   _mov_qi(num1, 65536);/* set num1 value */
	   _dec_q(num1);	/* num1 -- */
	   if (_cmp_qi(num1,num2) != 0)/* is num1 == num2 */
	      _put_str("Values are not equal!");
	   ...
	}

	#include <inline.h>
	{
	   quad num1;
	   ...
	   xor ax,ax	    
	   mov dx,1	/* DX;AX = 65536 */
	   lea di,num1	    /* DI = offset num1 */
	   mov_qi();	/* set num1 value */
	   dec_q();	/* num1-- */
	   mov ax,0xFFFF/* AX = 65535 */
	   cmp_qi();	/* is num1 = 65535 */
	    jl main_100/* if less jump to main_100 */
	    jg main_200/* if greater jump to main_200 */
	   _put_str("Values are equal.");
	main_100:
	   ...
	main_200:
	   ...
	}

_cmp_ql

Descrip

Compares a quad against a long.

Syntax

#include <imath.h>
int _cmp_ql(quad num1, long num2);

Returns

-1 if num1 is less than num2.

0 if num1 is equal to num2.

1 if num1 is greater than num2.

Notes

This function compares the quad value in num1 against the long value in num2. The return value indicates the result of the comparison.

	{
	   long num2 = 4294967295;
	   quad num1;

	   _mov_ql(num1, 4294967294);/* set num1 value */
	   _inc_q(num1);	/* num1++ */
	   if (_cmp_ql(num1,num2) != 0)/* is num1 == num2 */
	      _put_str("Values are not equal!");
	   ...
	}

	#include <inline.h>
	{
	   quad num1;
	   ...
	   mov ax,0xFFFE
	   mov dx,0xFFFF/* DX;AX = 4294967294 */
	   lea di,num1	    /* DI = offset num1 */
	   mov_ql();	/* set num1 value */
	   inc_q();	/* num1++ */
	   inc ax	 	/* DX;AX = 4294967295 */
	   cmp_ql();	/* quad == long? */
	    jl inc_q_010 /* jump if less than to label */
	    jg inc_q_020 /* jump if greater to label */
	   _put_str("Values are equal.");
	   ...
	inc_q_010:
	   ...
	inc_q_020:
	   ...
	}

_cmp_qq

Descrip

Compares two quad values.

Syntax

#include <imath.h>
int _cmp_qq(quad num1, quad num2);

Returns

-1 if num1 is less than num2.

0 if num1 is equal to num2.

1 if num1 is greater than num2.

Notes

This function compares the quad value in num1 against the quad value in num2. The return value reflects the result of the comparison.

	{
	   quad num1, num2;

	   _mov_ql(num1, 0xFFFFFFFF);/* set num1 value */
	   _mov_ql(num2, 0xFFFFFFFF);/* set num2 value */
	   if (_cmp_qq(num1,num2) != 0)/* is num1 == num2 */
	      _put_str("Values are not equal!");
	   ...
	}

	#include <inline.h>
	{
	   quad num1, num2;
	   ...
	   mov ax,0x1111
	   mov dx,0xFFFF/* DX;AX = 0xFFFF1111 */
	   lea di,num1	    /* DI = offset of num1 */
	   lea si,num2	    /* SI = offset of num2 */
	   mov_ql();
	   xchgdi,si	/* DI = offset of num2 */
	   mov_ql();
	   xchgdi,si	/* DI = offset of num1 */
	   cmp_qq();	/* quad == quad? */
	   
	    jl cmp_q_010 /* jump if less to label */
	    jg cmp_q_020 /* jump if greater to label */
	   _put_str("Values are equal.");
	   ...
	cmp_q_010:
	   ...
	cmp_q_020:
	   ...
	}

_cmp_uqi

Descrip

Compares a uquad against an unsigned int.

Syntax

#include <imath.h>
int _cmp_uqi(uquad num1, unsigned int num2);

Returns

-1 if num1 is less than num2.

0 if num1 is equal to num2.

1 if num2 is greater than num2.

Notes

This function compares the uquad value in num1 against the unsigned int value in num2. The return value reflects the result of the comparison.

	{
	   uquad num1;

	   _mov_uqi(num1, 65000);    /* set num1 value */
	   if (_cmp_uqi(num1, 65001) != 0)/* num1 == num2 */
	      _cput_str("Values are not equal");
	   ...
	}

	#include <inline.h>
	{
	   uquad num1;
	   ...
	   mov ax,65000
	   lea di,num1	    /* DI = offset of num1 */
	   mov_uqi();	/* set num1 value */
	   cmp_uqi();	/* num1 == num2? */
	    jnecmp_q_010 /* jump if not equal to label */
	   ...
	cmp_q_010:
	   ...
	}

_cmp_uql

Descrip

Compares a uquad against an unsigned long.

Syntax

#include <imath.h>
int _cmp_uql(uquad num1, unsigned long num2);

Returns

-1 if num1 is less than num2.

0 if num1 is equal to num2.

1 if num1 is greater than num2.

Notes

This function compares the uquad value in num1 against the unsigned long value num2. The return value reflects the result of the comparison.

	{
	   unsigned long num2 = 0x10000000;
	   uquad num1;

	   _mov_uql(num1, 0x10000000);
	   if(_cmp_uql(num1,num2) != 0)/* is num1 == num2 */
	      _put_str("Values are not equal!");
	   ...
	}

	#include <inline.h>
	{
	   unsigned long num2 = 0xFFFF1112;
	   uquad num1;
	   ...
	   mov ax,word ptr num2
	   mov dx,word ptr num2+2
	   lea di,num1	    /* DI = offset of num1 */
	   mov_uql();	/* set num1 value */
	   cmp_uql();	/* is num1 == num2 */
	    jnecmp_q_010 /* jump to label if not equal */
	   ...
	cmp_q_010:
	   ...
	}

_cmp_uqq

Descrip

Compares two uquad values.

Syntax

#include <imath.h>
int _cmp_uqq(uquad num1, uquad num2);

Returns

-1 if num1 is less than num2.

0 if num1 is equal to num2.

1 if num1 is greater than num2.

Notes

This function compares the uquad value in num1 against the uquad value in num2. The return value reflects the result of the comparison.

	{
	   uquad num1, num2;

	   _mov_uql(num1, 4000000001);	  /* set num1 value */
	   _mov_uql(num2, 4000000002);	  /* set num2 value */
	   _inc_q(num1);	    /* num1 ++ */
	   if (_cmp_uqq(num1, num2) != 0)/* is num1 == num2 */
	      _put_str("Values are not equal!");
	   ...
	}

	#include <inline.h>
	{
	   uquad num1, num2;
	   ...
	   lea di,num1	    /* DI = offset of num1 */
	   lea si,num2	    /* SI = offset of num2 */
	   mov ax,0x2801
	   mov dx,0xEE6B/* DX;AX = 4000000001 */
	   mov_ql();	/* set num1 value */
	   xchgsi,di	/* DI = offset of num2 */
	   inc ax	 	/* DX;AX = 4000000002 */
	   mov_ql();	/* set num2 value */
	   xchgsi,di	/* DI = offset of num1 */
	   inc_q();	/* num1 ++ */
	   cmp_uqq();	/* is num1 == num2 */
	    jnecmp_q_010:/* jump if not equal to label */
	   ...
	cmp_q_010:
	   ...
	}

_dec_q

Descrip

Decrements a quad or uquad.

Syntax

#include <imath.h>
quadptr _dec_q(uquad num);

Returns

A pointer to num.
num decremented quad value

Notes

This function decrements the quad value in num. A pointer to num is returned.

This function works on both quad and uquad values.

	{
	   quad num;
	   _mov_ql(num,0xFFFFFFFF);
	   _dec_q (num);	/* num = 0xFFFFFFFE */
	   ...
	}

	#include <inline.h>
	{
	   quad num;
	   ...
	   mov ax,0xFFFE
	   mov dx,0xFFFF/* DX;AX = 0xFFFFFFFE */
	   lea di,num	/* DI = offset of num */
	   mov_ql();	/* set num value */
	   dec_q();	/* num = 0xFFFFFFFD */
	    jc d_q_100	    	  
	   ... 	 	/* handle unsigned overflow */
	d_q_100:
	   ...
	}

_div_qi

Descrip

Divides a quad by an int, returning a quad result.

Syntax

#include <imath.h>
quadptr _div_qi(quad num, int divisor, int *remainder);

Returns

A pointer to num.
num quad quotient
remainder int remainder

Notes

This function divides the quad value in num by the int value in divisor. A pointer is returned to the quotient in num. The resulting int remainder is returned in remainder.
The remainder is positive if num is positive; otherwise, it is negative. The quotient is positive if num and divisor are both positive or both negative; otherwise, it is negative.

This function will not produce divide overflow interrupts (INT 0). The results are undefined if divisor = 0.

	{
	   int divisor, remainder;   
	   quad num;
	   _mov_qi(num, 65535);
	   divisor = 2;
	   _div_qi(num, divisor, &remainder);
	   ...
	}

	#include <inline.h>
	{
	   int remainder;
	   quad dividend;
	   ...
	   lea di,dividend /* DI = offset of dividend */
	   mov ax,65535    
	   mov_qi();	/* dividend = 65535 */
	   inc_q();	/* dividend++ */
	   mov ax,2	/* AX = divisor = 2*/
	   remainder = div_qi();/* num = num/65535 */
	   	  	 	/* (remainder = 0) */
	   ...
	}

_div_ql

Descrip

Divides a quad by a long, returning a quad result.

Syntax

#include <imath.h>
quadptr _div_ql(quad num, long divisor, long *remainder);

Returns

A pointer to num.
num quad quotient
remainder long remainder

Notes

This function divides num by divisor. A pointer is returned to the quotient in num. The resulting long remainder is returned in remainder.

The remainder is positive if num is positive; otherwise, it is negative. The quotient is positive if num and divisor are both positive or both negative; otherwise, it is negative.

This function will not produce divide overflow interrupts (INT 0). The results are undefined if divisor = 0.

Because this function performs bitwise long division (a relatively slow operation), it is advisable to call _div_qi instead if the divisor is an integer or less in size. This function is faster than _div_qq.

	{
	   char outstr[40];
	   long remainder;
	   quad num;
	   _mov_ql(num, 0xFFFFFFFF);/* set num value */
	   _inc_q(num);	 	/* num++ */
	   _put_str(_q_to_dec(div_ql(num, 2, &remainder), outstr));
		   	 /* display divide result */
	   ...
	}

	#include <inline.h>
	{
	   char outstr[40];
	   quad dividend;
	   ...
	   lea di,dividend /* DI = offset of dividend */
	   mov ax,0xFFFF
	   mov dx,0xFFFF/* DX;AX = 0xFFFFFFFF */
	   mov_ql();	/* set dividend value */
	   inc_q();	/* increment dividend */
	   mov ax,2
	   xor dx,dx	/* DX;AX = 2 (divisor) */
	   div_ql();	/* num = num/2 */
	   lea si,outstr/* SI = offset of outstr */
	   q_to_dec();	/* quotient -> "string" */
	   put_str();	/* display divide result */
	   ...
	}

_div_qq

Descrip

Divides one quad by another, returning a quad result.

Syntax

#include <imath.h>
quadptr _div_qq(quad num, quad divisor, quad remainder);

Returns

A pointer to num.
num quad quotient
remainder quad remainder

Notes

This function divides the quad dividend by the quad divisor. A pointer is returned to the quotient in num. The resulting quad remainder is returned in remainder.

divisor and remainder may be the same quad, in which case the divisor is overwritten by the remainder when the function returns.

This function will not produce divide overflow interrupts (INT 0). The results are undefined if divisor = 0.

Because this function performs bitwise long division (a relatively slow operation), it is advisable to call _div_qi instead if the divisor is an integer or less in size. This function is slower than _div_ql.

	{
	   quad num, divisor, remainder;
	   _mov_ql(num, 0xFFFFFFFF);
	   _add_ql(num, 0xFFFFFFFF);	/* num = 1FFFFFFFE */
	   _mov_qi(num, 2);	 	/* divisor = 2 */
	   _div_qq(num, divisor, remainder);/* num = num/2 */
	   ...
	}

	#include <inline.h>
	{
	   quad num, divisor, remainder;
	   ...
	   lea di,num	/* DS:DI -> dividend */
	   mov ax,0xFFFF
	   mov dx,0xFFFF/* DX;AX = 0xFFFFFFFF */
	   mov_ql();	/* set dividend value */
	   add_ql();	/* dividend = 1FFFFFFFE */
	   lea bx,divisor/* BX = offset of divisor */
	   lea si,remainder/* SI = offset of remainder */
	   xchgbx,di	/* DI = offset of divisor */
	   mov ax,2	/* AX = divisor value */
	   mov_ql();	/* divisor = 2 */
	   xchgbx,di	/* DI = offset of dividend, 
	   div_qq();	/* num = num/2 */
	   ...
	}

_divr_qi

Descrip

Divides a quad by an int, returning a rounded quad result.

Syntax

#include <imath.h>
quadptr _divr_qi(quad num, int divisor);

Returns

A pointer to num.
num rounded quad quotient

Notes

This function divides num by divisor. The resulting quad quotient is rounded up (incremented) if the absolute value of the remainder is greater than or equal to half the absolute value of the divisor. A pointer is returned to the quotient in num.

The quotient is positive if num and divisor are both positive or both negative; otherwise, it is negative.

This function does not generate divide overflow interrupts (INT 0). The result is undefined if divisor = 0 or if the quotient is the largest possible signed number before rounding is performed.

	{
	   int divisor = 2;   
	   quad num;
	   _mov_ql(num, 0x80000000);/* set num value */
	   _divr_qi(num, divisor);  /* num = num/divisor = 0x40000000 */
	   ...
	}

	#include <inline.h>
	{
	   quad num;
	   ...
	   xor ax,ax
	   mov dx,0x8000/* DX;AX = 0x80000000 */
	   lea di,num	/* DI = offset of dividend */
	   mov_ql();	/* set dividend value */
	   mov bx,2	/* BX = 2 (divisor) */
	   divr_qi();	/* num = num/2 = 0x40000000 */
	   ...
	}

_divr_ql

Descrip

Divides a quad by a long, returning a rounded quad result.

Syntax

#include <imath.h>
quadptr _divr_ql(quad num, long divisor)

Returns

A pointer to num.
num rounded quad quotient

Notes

This function divides num by divisor. The resulting quad quotient is rounded (incremented if positive, decremented if negative) if the absolute value of the remainder is greater than or equal to half the absolute value of the divisor. A pointer is returned to the rounded quotient in num.

The quotient is positive if num and divisor are both positive or both negative; otherwise, it is negative. The results are undefined if divisor = 0.

This function will not generate divide overflow interrupts (INT 0). The results are undefined if divisor = 0.

Because this function performs bitwise long division (a relatively slow operation) it is advisable to call _divr_qi instead if the divisor is an integer or less in size. This function is faster than _divr_qq.

	{
	   long divisor = 5;   
	   quad num;
	   _mov_ql(num, 0x80000001);/* set num value */
	   _divr_ql(num, divisor); /* num /= divisor = 0x19999999 */
	   ...
	}

	#include <inline.h>
	{
	   quad num;
	   ...
	   mov ax,1
	mov dx,0x8000/* DX;AX = 0x80000001 */
	lea di,num	 /* DI = offset of dividend */
	mov_ql();	 /* set dividend value */
	mov cx,5
	xor bx,bx	 /* CX;BX = 5 (divisor) */
	divr_ql();	 /* num = num/5 */
	...
	}

_divr_qq

Descrip

Divides one quad by another, returning a rounded quad result.

Syntax

#include <imath.h>
quadptr _divr_qq(quad num, quad divisor);

Returns

A pointer to num.
num rounded quad quotient

Notes

This function divides num by divisor. The resulting quad quotient is rounded (incremented if positive, decremented if negative) if the absolute value of the remainder is greater than or equal to half the absolute value of the divisor. A pointer is returned to the rounded quotient in num.

The quotient is positive if num and divisor are both positive or both negative; otherwise, it is negative.

This function will not generate divide overflow interrupts (INT 0). The results are undefined if divisor = 0.

Because this function performs bitwise long division (a relatively slow operation), it is advisable to call _divr_qi instead if the divisor is an integer or less in size. This function is slower than _divr_ql.

	{
	   uquad num, divisor;
	   _mov_uql(num, 0xFFFFFFFF);/* set num value */
	   _inc_q(num);	    /* num = 0x100000000 */
	   _mov_uqi(num, 2);	/* set divisor value */
	   _divr_uqq(num, divisor); /* num = num/divisor = 0x80000000 */
	   ...
	}

	#include <inline.h>
	{
	   uquad num, divisor;
	   ...
	   mov ax,0xFFFF
	   mov dx,0xFFFF/* DX;AX = 0XFFFFFFFF */
	   lea di,num	/* DI = offset of dividend */
	   lea bx,divisor/* BX = offset of divisor */
	   mov_uql();	/* set dividend value */
	   inc_q(num);	/* dividend = 0x100000000 */
	   mov ax,2
	   xchgdi,bx	/* DI = offset of divisor */
	   mov_qi();	/* divisor = 2 */
	xchgdi,bx	 /* DI = offset of dividend */
	divr_uqq();	 /* num = num/divisor */
	...
	}

_divr_uqi

Descrip

Divides a uquad by an unsigned int, returning a rounded uquad result.

Syntax

#include <imath.h>
quadptr _divr_uqi(uquad num, unsigned int divisor);

Returns

A pointer to num.
num rounded uquad quotient

Notes

This function divides num by divisor. The resulting uquad quotient is rounded up (incremented) if the remainder is greater than or equal to half the divisor. A pointer is returned to the rounded quotient in num.

This function does not generate divide overflow interrupts (INT 0). The result is undefined if divisor = 0 or if the quotient is the largest possible unsigned number before rounding is performed.

	{
	   char outstr[40];   
	   uquad num;
	   _mov_uqi(num,65535);    /* set dividend (num) */
	   _inc_uq(num);	/* dividend = 65536 */
	   _divr_uqi(num,2);	/* num = num/2 = 0x8000 */
	   _put_str(_uq_to_dec(num, outstr));
	   ...
	}

	#include <inline.h>
	{
	   char outstr[40];
	   uquad dividend;
	   ...
	   mov ax,FFFF	    /* AX = 65535 */
	   lea di,dividend/* DI = offset of dividend */
	   mov_uqi()	/* set dividend value */
	   inc_q();	/* dividend++ */
	   mov bx,2	/* BX = divisor */
	   divr_uqi();	/* num = num/2 = 0x8000 */
	   lea si,outstr/* SI = offset of outstr */
	   uq_to_dec();	/* quad -> "string" */
	   put_str();	/* display quotient result */
	   ...
	}

_divr_uql

Descrip

Divides a uquad by an unsigned long, returning a rounded uquad result.

Syntax

#include <imath.h>
quadptr _divr_uql(uquad num, unsigned long divisor)

Returns

A pointer to num.
num rounded uquad quotient

Notes

This function divides num by divisor. The resulting uquad quotient is rounded up (incremented) if the remainder is greater than or equal to half the divisor. A pointer is returned to the rounded quotient in num.

This function does not generate divide overflow interrupts (INT 0). The result is undefined if divisor = 0 or if the quotient is the largest possible unsigned number before rounding is performed.

Because this function performs bitwise long division (a relatively slow operation), it is advisable to call _divr_qi instead if divisor is an integer or less in size. This function is faster than _divr_uqq.

	{
	   unsigned long divisor = 2;
	   uquad num;
	   _mov_uql(num, 0xFFFFFFFF);
	   _inc_q(num);	    /* num = 0x100000000 */
	   _divr_uql(num, divisor);/* num = num/divisor */
	   ...
	}

	#include <inline.h>
	{
	   uquad num;
	   ...
	   mov ax,0xFFFF
	   mov dx,0xFFFF/* DX;AX = 0xFFFFFFFF */
	   lea di,num	/* DI = offset of dividend */
	   mov_uql();	/* set dividend value */
	   inc_q(num);	/* dividend = 0x100000000 */
	   mov bx,2
	   xor cx,cx	/* CX;BX = 2 (divisor) */
	   divr_uql();	/* num = num/2 */
	   ...
	}

_divr_uqq

Descrip

Divides one uquad by another, returning a rounded uquad result.

Syntax

#include <imath.h>
quadptr _divr_uqq(uquad num, uquad divisor);

Returns

A pointer to num.
num rounded uquad quotient

Notes

This function divides num by divisor. The resulting uquad quotient is rounded up (incremented) if the remainder is greater than or equal to half the divisor. A pointer is returned to the rounded quotient in num.
This function does not generate divide overflow interrupts (INT 0). The result is undefined if divisor = 0 or if the quotient is the largest possible unsigned number before rounding is performed.

Because this function performs bitwise long division (a relatively slow operation), it is advisable to call _divr_uqi instead if divisor is an integer or less in size. This function is slower than _divr_uql.

	{
	   char outstr[40];
	   uquad num, divisor;
	   _mov_uql(num, 0xFFFFFFFF);
	   _add_uql(num, 0xFFFFFFFF);/* num = 1FFFFFFFE */
	   _mov_uql(num, 2);
	   _uq_to_dec(_divr_uqq(num, divisor), outstr);
	   	  	 	/* num = num/divisor */
	   _put_str(outstr);	/* display quotient result */
	   ...
	}

	#include <inline.h>
	{
	   char outstr[40];
	   uquad num, divisor = 2;
	   ...
	   lea di,num	/* DI = offset of dividend */
	   xor dx,dx
	   mov ax,0xFFFFFFFF/* DX;AX = unsigned long */
	   mov_uql();	/* set dividend value */
	   add_uql();	/* dividend += dividend */
	   lea bx,divisor/* BX = offset of divisor */
	   divr_uql();	/* dividend/divisor */
	   lea si,outstr/* SI = offset of outstr */
	   uq_to_dec();	/* convert result to "string" */
	   put_str();	/* display result */
	   ...
	}

_div_uqi

Descrip

Divides a uquad by an unsigned int, returning a uquad result.

Syntax

#include <imath.h>
quadptr _div_uqi(uquad num, unsigned int divisor, unsigned int *remainder);

Returns

A pointer to num.
num uquad quotient
remainderunsigned int remainder

Notes

This function divides the uquad value in num by the unsigned int value in divisor. A pointer is returned to the resulting quotient in num. The resulting unsigned int remainder is returned in remainder.

This function will not generate divide overflow interrupts (INT 0). The results are undefined if divisor = 0.

	{
	   unsigned int divisor, remainder;   
	   uquad num;
	   _mov_uqi(num,65535);
	   divisor = 2;
	   _div_uqi(num,divisor,&remainder);
	   ...
	}

	#include <inline.h>
	{
	   unsigned int divisor, remainder;
	   uquad num;
	   ...
	   mov ax,65534
	   lea di,num	/* DI = offset of dividend */
	   mov_uqi();	/* set dividend value */
	   divisor = 2;
	   mov ax,divisor/* AX = 2 */
	   remainder = div_uqi();
	   ...
	}

_div_uql

Descrip

Divides a uquad by an unsigned long, returning a uquad result.

Syntax

#include <imath.h>
quadptr _div_uql(uquad num, signed long divisor, unsigned long *remainder);

Returns

A pointer to num.
num uquad quotient
remainderunsigned long remainder

Notes

This function divides the uquad value in num by the unsigned long value in divisor. A pointer is returned to the resulting quotient in num. The resulting unsigned long remainder is returned in remainder.

This function will not generate divide overflow interrupts (INT 0). The results are undefined if divisor = 0.

Because this function performs bitwise long division (a relatively slow operation), it is advisable to call _div_uqi instead if divisor is an integer or less in size. This function is faster than _div_uqq.

	{
	   char outstr[40];
	   unsigned long divisor, remainder;
	   uquad num;
	   _mov_uql(num,4000000000);
	   divisor = 3;
	   _div_uql(num,divisor,&remainder);
	   _put_str(_ul_to_dec(remainder, outstr));
	   	  	 	/* display remainder */
	   ...
	}

	#include <inline.h>
	{
	   char outstr[40];
	   unsigned long divisor, remainder;
	   uquad num;
	   ...
	   _mov_uql(dividend,4000000000);
	   divisor=2;
	   lea di,num	/* DI = offset of dividend */
	   mov bx,word ptr divisor
	   xor cx,cx	/* CX;BX = divisor */
	   remainder = div_uql();
	   lea si,outstr/* SI = offset of outstr */
	   mov ax,word ptr remainder
	   mov dx,word ptr remainder+2
	   ul_to_dec();	/* long -> "string" */
	   put_str();	/* display remainder value */
	   ...
	}

_div_uqq

Descrip

Divides a uquad by a uquad, returning a uquad result.

Syntax

#include <imath.h>
quadptr _div_uqq(uquad num, uquad divisor, uquad remainder);

Returns

A pointer to num.
num uquad quotient
remainder uquad remainder

Notes

This function divides the uquad value in num by the uquad value in divisor. A pointer is returned to the resulting quotient in num. The resulting uquad remainder is returned in remainder.

This function will not generate divide overflow interrupts (INT 0). The results are undefined if divisor = 0.

divisor and remainder may be the same uquad, in which case the divisor is overwritten by the remainder when the function returns.

Because this function performs bitwise long division (a relatively slow operation), it is advisable to call _div_uqi instead if the divisor is an integer or less in size. This function is slower than _div_uql.

	{
	   char outstr[22];
	   uquad num, divisor, remainder;
	   _mov_uql(num, 0xFFFFFFFF);
	   _mov_uql(divisor, 0xFFFFFFFE);
	   _div_uqq(num, divisor, remainder); /* num = num / divisor */
	   _uq_to_dec(num, outstr);
	   _put_str(outstr);/* display resulting quotient */
	   ...
	}

	#include <inline.h>
	{
	   char outstr;
	   uquad dividend, divisor, remainder;
	   ...
	   _mov_uql(dividend, 0xFFFFFFFF);/* set dividend value */
	   _mov_uql(divisor, 0xFFFFFFFE);/* set divisor value */
	   lea di,dividend/* DI = offset of dividend */
	   lea bx,divisor/* BX = offset of divisor */
	   lea si,remainder/* SI = offset of remainder */
	   div_uqq();	/* divide quads */
	   lea si,outstr
	   uq_to_dec();	/* quad -> "string" */
	   put_str();	/* display resulting quotient */
	   ...
	}

_inc_q

Descrip

Increments a quad or uquad.

Syntax

#include <imath.h>
quadptr _inc_q(uquad num);

Returns

A pointer to num.
num incremented quad value

Notes

This function increments the quad value in num. A pointer to the quad result is returned.

This function works on both quad and uquad values.

	{
	   uquad num;
	   _mov_ql(num,0xFFFFFFFF);
	   _inc_q(num);	/* num = 0x100000000 */
	   ...
	}

	#include <inline.h>
	{
	   quad num;
	...
	lea di,num	 /* DI = offset of num */
	mov ax,0xFFFF
	mov dx,0xFFFF/* DX;AX = 0xFFFFFFFF */
	mov_ql();	 /* set num value */
	inc_q();	 /* num = 0x100000000 */
	 jo i_q_100
	...    	 /* handle signed overflow */
	i_q_100:
	...
	}

_mov_qi

Descrip

Moves the value of an int into a quad.

Syntax

#include <imath.h>
quadptr _mov_qi(quad num1, int num2);

Returns

A pointer to num1.
num1 quad result (value of num2)

Notes

This function sign-extends the int value in num2 and moves it into num1. A pointer to num1 is returned.

	   ...
	   quad num1;
	   _inc_q(_mov_qi(num1, 65535)); /* num1 = 65536 */
	   ...

	#include <inline.h>
	{
	   quad num1;
	   ...
	   mov ax,65535/* AX = int to move to num1 */
	   lea di,num1	    /* DI = offset of num1 */
	   mov_qi();	/* load num1 w/int value */
	   inc_q();	/* num1 = 65536 */
	   ...
	}

_mov_ql

Descrip

Moves the value of a long into a quad.

Syntax

#include <imath.h>
quadptr _mov_ql(quad num1, long num2);

Returns

A pointer to num1.
num1 quad result (value of num2)

Notes

This function sign-extends the long value in num2 and moves it into num1. A pointer to num1 is returned.

	   ...
	   quad num1;
	   _dec_q(_mov_ql (num1, 0x80000000)); /* num1 = 0x7FFFFFFF */
	   ...

	#include <inline.h>
	{
	   quad num1;
	   ...
	   xor ax,ax
	   mov dx,0x8000/* DX;AX = num2 */
	   lea di,num1	    /* DI = offset of num1 */
	   mov_ql();	/* set num1 value */
	   dec_q();	/* num1 = 0x7FFFFFFF */
	   ...
	}

_mov_qq

Descrip

Moves the value of a quad into another quad.

Syntax

#include <imath.h>
quadptr _mov_qq(quad num1, quad num2);

Returns

A pointer to num1.
num1 quad result (value of num2)

Notes

This function moves the quad value in num2 into num1. A pointer to num1 is returned.

This function may be used interchangeably with _mov_uqq (_mov_uqq and _mov_qq are two different names for the same function).

	{
	   char *strindx;
	   quad num1, num2;
	   ...
	   _dec_to_q("10000000000000000000", num1, &strindx);
	   if ((strindx[0] == NULL) && (c_code == 0))
	      _mov_qq (num2, num1);
	   /* num2 = num1 = 10,000,000,000,000,000,000 */
	   ...
	}

	#include <inline.h>
	{
	   quad num1, num2;
	   char instr[] = "10000000000000000000";
	   ...
	   lea si,instr/* SI = offset of instr */
	   lea di,num2	    /* ES:DI = offset of num2 */
	   dec_to_q();/* num2 = 10,000,000,000,000,000,000 */
	    jnem_qq_100/* jump to label if underflow */
	   lea si,num1	    /* SI = offset of num1 */
	   xchgdi,si	/* DI = offset of num1 */
	   mov_qq();/* num2 = 10,000,000,000,000,000,000 */
	m_qq_100:
	   ...
	}

_mov_uqi

Descrip

Moves the value of an unsigned int into a uquad.

Syntax

#include <imath.h>
quadptr _mov_uqi(uquad num1, unsigned int num2);

Returns

A pointer to num1.
num1 uquad result (value of num2)

Notes

This macro moves the unsigned int value in num2 into num1. A pointer to num1 is returned.

	{
	   uquad num1;
	   _inc_q(_mov_uqi(num1, 65535)); /* num1 = 65535++ */
	   ...
	}

	#include <inline.h>
	{
	   uquad num1;
	   ...
	   mov ax,65535
	   lea di,num1	    /* DI = offset of num1 */
	   mov_uqi();	/* load quad w/int value */
	   inc_q();	/* num1 = 0x10000 */
	   ...
	}

_mov_uql

Descrip

Moves the value of an unsigned long into a uquad.

Syntax

#include <imath.h>
quadptr _mov_uql(uquad num1, unsigned long num2);

Returns

A pointer to num1.
num1 uquad result (value of num2)

Notes

This function moves the unsigned long value in num2 into num1. A pointer to num1 is returned.

	{
	   uquad num1;
	   _inc_q(_mov_uql (num1, 4000000000)); /* num1 = 4000000001 */
	   ...
	}

	#include <inline.h>
	{
	   uquad num1;
	   ...
	   lea di,num1	    /* DI = offset of num1 */
	   mov ax,0x2800
	   mov dx,0xEE6B/* DX;AX = 0xEE6B2800 */
	   mov_uql();	/* num1 = 0xEE6B2800 */
	   inc_q();	/* num1 = 4000000001 */
	   ...
	}

_mov_uqq

Descrip

Moves the value of a uquad into another uquad.

Syntax

#include <imath.h>
quadptr _mov_uqq(uquad num1, uquad num2);

Returns

A pointer to num1.
num1 uquad result (value of num2)

Notes

This function moves the uquad value in num2 into num1. A pointer to num1 is returned.

This function may be used interchangeably with _mov_qq (_mov_uqq and _mov_qq are two different names for the same function).

	{
	   char *strindx;
	   uquad num1, num2;
	   ...
	   _dec_to_uq("1000000000000000000", num1, &strindx);
	   if ((strindx[0] == NULL) && (c_code == 0))
	      _mov_uqq (num2, num1);
	      /* num2 = num1 = 1,000,000,000,000,000,000 */
	   ...
	}

	#include <inline.h>
	{
	   uquad num1, num2;
	   char instr[] = "1000000000000000000";
	   ...
	   lea si,instr/* SI = offset of instr */
	   lea di,num2	    /* ES:DI = offset of num2 */
	   dec_to_uq();/* num2 = 1,000,000,000,000,000,000 */
	    jnelabel_100/* underflow */
	   lea si,num1	    /* SI = offset of num1 */
	   xchgdi,si	/* DI = offset of num1 */
	   mov_uqq();/* num2 = 1,000,000,000,000,000,000 */
	label_100:
	   ...
	}

_mul_qi

Descrip

Multiplies a quad by an int, returning a quad result.

Syntax

#include <imath.h>
quadptr _mul_qi(quad num1, int num2);

Returns

A pointer to num1.
num1 quad result (num1ūnum2)

Notes

This function multiplies the quad value in num1 by the int value in num2. A pointer is returned to num1, which contains the quad result.

The result is undefined if arithmetic overflow occurs.

	{
	   quad num1;
	   _mov_qi(num1, 65535); /* num1 = 65535 */
	   _mul_qi(num1, 2);/* num1 = num1 * 2 = (131070) */
	   ...
	}

	#include <inline.h>
	{
	   quad num1;
	   ...
	   lea di,num1	    /* DI = offset of num1 */
	   mov ax,65535
	   mov_qi();	/* num1 = 65535 */
	   mov ax,2
	   mul_qi();	/* num1 = num1*2 = (131070) */
	   ...
	}

_mul_ql

Descrip

Multiplies a quad by a long, returning a quad result.

Syntax

#include <imath.h>
quadptr _mul_ql(quad num1, long num2);

Returns

A pointer to num1.
num1 quad result (num1ūnum2)

Notes

This function multiplies the quad value in num1 by the long value in num2. A pointer is returned to num1, which contains the long result.

The result is undefined if arithmetic overflow occurs.

	{
	   char outstr[22];
	   quad num1;
	   _mov_ql(num1, 0xFFFFFFFF);
	   _q_to_dec(_mul_ql(num1, 2), outstr);
	   /* num1 = num1 * 2 (1FFFFFFFE) */
	   _put_str(outstr);/* display product */
	   ...
	}

	#include <inline.h>
	{
	   char outstr[22];
	   quad num1;
	   ...
	   mov ax,0xFFFF
	   mov dx,0xFFFF/* DX;AX = 0xFFFFFFFF ) */
	     lea di,num1 	/* DI = offset of num1 */
	    mov_ql();	 /* num1 = 0xFFFFFFFF ) */
	    mov bx,2
	    xor cx,cx	 /* CX;BX = 2 */
	    mul_ql();	 /* num1 = num1*2 (1FFFFFFFE) */
	    lea si,outstr/* SI = offset of outstr */
	    q_to_dec();	 /* product -> "string" */
	    put_str();	 /* display result */
	    ...
	}

_mul_qq

Descrip

Multiplies one quad by another, returning a quad result.

Syntax

#include <imath.h>
quadptr _mul_qq(quad num1, quad num2);

Returns

A pointer to num1.
num1 quad result (num1ūnum2)

Notes

This function multiplies the quad value in num1 by the quad value in num2. A pointer is returned to num1, which contains the quad result.

The result is undefined if arithmetic overflow occurs.

This function is slower than _mul_qi and _mul_ql. If speed is the primary concern and the multiplier is only an int or long in size, _mul_qi or _mul_ql should be used instead of this function.

This function may be used interchangeably with _mul_uqq (_mul_uqq and _mul_qq are two different names for the same function).

	{
	   quad num1, num2;
	   _mov_ql(num1,0x7FFFFFFF);
	   _mov_qq(num2,num1);
	   _mul_qq(num1,num2);/* num1 = num1 * num2 */
	   ...
	}

	#include <inline.h>
	{
	   quad num1, num2;
	   ...
	   mov ax,0xFFFF
	   mov dx,0x7FFF/* DX;AX = 0x7FFFFFFF */
	   lea di,num1	    /* DI = offset of num1 */
	   mov_ql();	/* num1 = 0x7FFFFFFF */
	   lea bx,num2	    /* BX = offset of num2 */
	   xchgdi,bx	/* DI = offset of num2 */
	   mov_qq();	/* num2 = num1 */ 
	   xchgdi,bx	/* DI = offset of num1 */
	   mul_qq();	/* num1 = num1 * num2 */
	    ...
	}

_mul_uqi

Descrip

Multiplies a uquad by an unsigned int, returning a uquad result.

Syntax

#include <imath.h>
quadptr _mul_uqi(uquad num1, unsigned int num2);

Returns

A pointer to num1.
num1 uquad result (num1ūnum2)

Notes

This function multiplies the uquad value in num1 by the unsigned int value in num2. A pointer is returned to num1, which contains the uquad result.

	{
	   quad num1;
	   _mov_uqi(num1,0xFFFF);
	   _mul_uqi(num1,0xFFFF); /* num1 = 0xFFFF * 0xFFFF = 0xFFFE0001*/
	   ...
	}

	#include <inline.h>
	{
	   char instr[] = "17204400";
	   quad num1;
	   ...
	   lea di,num1	    /* DI = offset of num1 */
	   lea si,instr/* SI = offset of instr */
	   mov bl,8	/* use octal radix */
	   asc_to_uq();	/* set num1 value */
	   mov bx,10	/* num1 = num1 * 10 */
	   mul_uqi();	/* num1 = 40000000 */
	   ...
	}

_mul_uql

Descrip

Multiplies a uquad by an unsigned long, returning a uquad result.

Syntax

#include <imath.h>
quadptr _mul_uql(uquad num1, unsigned long num2);

Returns

A pointer to num1.
num1 uquad result (num1ūnum2)

Notes

This function multiplies the uquad value in num1 by the unsigned long value in num2. A pointer is returned to num1, which contains the uquad result.

This function is two to three times slower than _mul_uqi. If speed is the primary concern and the multiplier is an integer or less in size, _mul_uqi should be used instead of this function.

	{
	   uquad num1;
	   _mov_uql(num1, 0xFFFFFFFF);
	   _mul_uql(num1, 0xFFFFFFFF); /* num1 = 0xFFFFFFFE00000001 */
	   ...
	}

	#include <inline.h>
	{
	   uquad num1;
	   ...
	   mov dx,0xFFFF
	   mov ax,0xFFFF/* DX;AX = 0xFFFFFFFF */
	   lea di,num1	    /* DI = offset of num1 */
	   mov_uql();	/* num1 = 0xFFFFFFFF */
	   mov cx,dx	    
	   mov bx,ax	/* CX;BX = 0xFFFFFFFF */
	   mul_uql();	/* num1 = 0xFFFFFFFE00000001 */
	   ...
	}

_mul_uqq

Descrip

Multiplies one uquad by another, returning a uquad result.

Syntax

#include <imath.h>
quadptr _mul_uqq(uquad num1, uquad num2);

Returns

A pointer to num1.
num1 uquad result (num1ūnum2)

Notes

This function multiplies the uquad value in num1 by the uquad value in num2. A pointer is returned to num1, which contains the uquad result.

This function is slower than _mul_uqi and _mul_uql. If speed is the primary concern and the multiplier is only an unsigned int or unsigned long in size, _mul_uqi or _mul_uql should be used instead of this function.

This function may be used interchangeably with _mul_qq (_mul_uqq and _mul_qq are two different names for the same function).

	{
	   uquad num1, num2;
	   _mov_uql(num1,0xFFFFFFFF);
	   _mov_uqq(num2,num1);
	   _mul_uqq(num1,num2);/* num1 = num1 * num2 */
	   ...
	}

	#include <inline.h>
	{
	   uquad num1, num2;
	   ...
	   mov ax,0xFFFF
	   mov dx,0xFFFF/* DX;AX = 0xFFFFFFFF */
	   lea di,num1	    /* DI = offset of num1 */
	   mov_uql();	/* num1 = 0xFFFFFFFF */
	   lea bx,num2	    /* BX = offset of num2 */
	   xchgdi,bx	/* DI = offset of num2 */
	   mov_uqq();	/* num2 = num1 */ 
	   xchgdi,bx	/* DI = offset of num1 */
	   mul_uqq();	/* num1 = num1 * num2 */
	   ...
	}

_neg_q

Descrip

Negates a quad.

Syntax

#include <imath.h>
quadptr _neg_q(quad num);

Returns

A pointer to num.
num negated quad result

Notes

This function negates the quad value in num. A pointer to num is returned.

	{
	   ...
	   quad num;
	   _mov_ql(num,0xFFFFFFFF);
	   if(!_sgn_q(num));/* if not negative */
	      _neg_q(num);/*   negate... */
	   ...
	}

	#include <inline.h>
	{
	   quad num;
	   ...
	   lea di,num	/* DI = offset of num */
	   mov ax,0xFFFF
	   mov dx,0x7FFF/* DX:AX = 0xFFFFFFFF */
	   mov_ql();	/* num = 0xFFFFFFFF */
	   sgn_q();	/* is num negative? */
	    js neg_q_100/*   n: make negative */
	   neg_q();	/* negate... */
	neg_q_100:
	   ...
	}

See also

_abs_q

_rand_init

Descrip

Initializes the random number generator.

Syntax

#include <imath.h>
void _rand_init(void);

Returns

No return value
rand_seed randomly initialized

Notes

This function initializes the random number generator by placing the current system timer count (slightly modified) into rand_seed.

The random number generator must be initialized (using this function or a similar method) or an identical sequence of numbers will be generated each time the calling program is run.

	 
	{
	   unsigned num;
	   ...
	   _rand_init();
	   num = _rand_w();
	   ...
	}

	#include <inline.h>
	{
	   unsigned num;
	   ...
	   rand_init();
	   num = rand_w();
	   ...
	}

See also

_randr_w, rand_seed, _rand_w

_randr_w

Descrip

Generates a random number within a specific range.

Syntax

#include <imath.h>
unsigned int _randr_w(unsigned int limit);

Returns

An unsigned random number in the range 0 to limit-1.
rand_seed modified for subsequent call

Notes

This function generates a pseudo-random number which has a value between zero and limit-1, inclusive. The random number is the return value.

If limit is zero, an unsigned int result is generated (0 through 65535).

rand_seed may be initialized to prevent the random number generator from generating an identical sequence of numbers each time the calling program is run. The _rand_init function is provided for this purpose.

The random number sequences generated by this function have a period of 230.

	{
	   ...
	   unsigned int num;
	   _rand_init();/* initialize random number generator */
	   num = _randr_w(1000); /* num = random number from 0 to 999 */
	   ...
	}

	#include <inline.h>
	{
	   unsigned int num;
	   ...
	   mov bx,1000	/* BX = limit */
	   num = randr_w();/* num = random num (0 to 999) */
	   ...
	}

See also

_rand_init, rand_seed, _rand_w

rand_seed

Descrip

Holds the seed value for the random number generator.

Syntax

#include <imath.h>
extern unsigned long rand_seed;

Notes

This unsigned long variable is used and modified each time _rand_w or randr_w is called.

rand_seed should be initialized to prevent the random number generator from generating an identical sequence of numbers each time the calling program is run. The rand_init functions is provided for this purpose.

rand_seed may be set to any unsigned long value. If it is initialized to zero, a degenerate random number sequence will result (all zeros).

The same sequence of random numbers may be generated repeatedly by setting rand_seed to a known value each time the sequence is to be restarted.

See also

_rand_init, _randr_w, _rand_w

_rand_w

Descrip

Generates a random number.

Syntax

#include <imath.h>
unsigned int _rand_w(void);

Returns

A random number.
rand_seed modified for subsequent call

Notes

This function generates a pseudo-random number using the seed value in rand_seed. The random number is returned, and saved in rand_seed for use in generating the next random number.

rand_seed may be initialized to prevent the random number generator from generating an identical sequence of numbers each time the calling program is run. The _rand_init function is provided for this purpose.

The random number sequences generated by this function have a period of 230.

	{
	   unsigned num;
	   ...
	   _rand_init();
	   num = _rand_w();
	   ...
	}

	#include <inline.h>
	{
	   unsigned num;
	   ...
	   rand_init();
	   num = rand_w();
	   ...
	}

See also

_rand_init, _randr_w, rand_seed

_sgn_q

Descrip

Determines the sign of a quad.

Syntax

#include <imath.h>
int _sgn_q(quad num);

Returns

1 if num is negative.

0 if num is positive.

Notes

This function determines the sign of the quad value in num. 1 is returned if num is negative. 0 is returned if num is positive.

	{
	   quad num;
	   _mov_ql(num,0xFFFFFFFF);
	   if(_sgn_q(num));/* is num negative? */
	      _abs_q(num);/*   y: make positive */
	   ...
	}

	#include <inline.h>
	{
	quad num;
	   ...
	   lea di,num	/* DI = offset of num */
	   mov ax,0xFFFF
	   mov dx,0x7FFF/* DX:AX = 0xFFFFFFFF */
	   mov_ql();	/* num = 0xFFFFFFFF */
	   sgn_q();	/* is num negative? */
	    jnssgn_q_100/*   y: make positive */
	   abs_q();
	sgn_q_100:
	   ...
	}

_sub_qi

Descrip

Subtracts an int from a quad.

Syntax

#include <imath.h>
quadptr _sub_qi(quad num1, int num2);

Returns

A pointer to num1.
num1 the quad result (num1 - num2)

Notes

This function subtracts the int value in num2 from the quad value in num1. A pointer is returned to num1, which contains the quad result.

	{
	   quad num1;
	   _mov_qi(num1, 65535);
	   _sub_qi(num1, 65530);  /* num1 -= 65530 = 5 */
	   ...
	}

	#include <inline.h>
	{
	   quad num1;
	...
	mov ax,65535
	lea di,num1	/* DI = offset of num */
	mov_qi();	 /* set num1 value */
	mov ax,65530
	sub_qi();	 /* num1 -= 65530 */
	 jnos_qi_100
	...    	 /* handle overflow */
	s_qi_100:
	...
	}

_sub_ql

Descrip

Subtracts a long from a quad.

Syntax

#include <imath.h>
quadptr _sub_ql(quad num1, long num2);

Returns

A pointer to num1.
num1 the quad result (num1 - num2)

Notes

This function subtracts the long value in num2 from the quad value in num1. A pointer is returned to num1, which contains the quad result.

	{
	   quad num1;
	   _mov_ql(num1,4000000000);/* set num1 value */
	   _sub_ql(num1,3999999999);/* num1 -= 3999999999 = 1 */
	   ...
	}

	#include <inline.h>
	{
	   quad num1;
	   ...
	   mov ax,0x2800
	   mov dx,0xEE6B/* DX;AX = 4000000000 */
	   lea di,num1	    /* DI = offset of num1 */
	   mov_ql();
	   dec ax	 	/* AX = 0x27FF */
	   sub_ql();	/* num1 -= 4000000000 = 1 */
	    jno s_ql_100
	...    	 /* handle overflow */
	s_ql_100:
	...
	}

_sub_qq

Descrip

Subtracts a quad from another quad.

Syntax

#include <imath.h>
quadptr *_sub_qq(quad num1, quad num2);

Returns

A pointer to num1.
num1 the quad result (num1 - num2)

Notes

This function subtracts the quad value in num2 from the quad value in num1. A pointer is returned to num1, which contains the quad result.

This function may be used interchangeably with _sub_uqq (_sub_uqq and _sub_qq are two different names for the same function).

	{
	   quad num1, num2;
	   _mov_ql(num1,1999999999);
	   _mov_ql(num2,1234567890);
	   _sub_qq(num1,num2);    /* num1 -= num2 = 765432109 */
	   ...
	}

	#include <inline.h>
	{
	   quad num1, num2;
	   ... 
	   lea di,num1	    /* DI = offset of num1 */
	   lea si,num2	    /* SI = offset of num2 */
	   mov dx,0x7735
	   mov ax,0x93FF/* DX;AX = 1999999999 */
	   mov_ql();	/* set num1 value */
	   mov dx,0x4996
	   mov ax,0x02D2/* DX;AX = 1234567890 */
	   xchgdi,si	/* DI = offset of num2 */
	   mov_ql();	/* set num2 value */
	   xchgdi,si	/* DI = offset of num1 */
	   sub_qq();	/* num1 -= num2 = 765432109 */
	    jnos_qq_100
	   ... 	 	/* handle overflow */
	s_qq_100:
	...
	}

_sub_uqi

Descrip

Subtracts an unsigned int from a uquad.

Syntax

#include <imath.h>
quadptr _sub_uqi(uquad num1, unsigned int num2);

Returns

A pointer to num1.
num1 the uquad result (num1 - num2)

Notes

This function subtracts the unsigned int value in num2 from the uquad value in num1. A pointer is returned to num1, which contains the uquad result.

	{
	   uquad num1;
	   _mov_qi(num1,0);
	   _sub_qi(num1,1);/* num1 = 0xFFFFFFFFFFFFFFFF */
	   ...
	}

	#include <inline.h>
	{
	   uquad num1;
	   ...
	   mov ax,12345
	   lea di,num1	    /* DI = offset of num1 */
	   mov_qi();	/* num1 = 12345 */
	   mov ax,12335/* AX = AX - 10 */
	   sub_qi();	/* num1 -= 12335 = 10 */
	    jncs_qi_100    
	   ... 	 	/* handle overflow */
	s_qi_100:
	   ...
	}

_sub_uql

Descrip

Subtracts an unsigned long from a uquad.

Syntax

#include <imath.h>
quadptr _sub_uql(uquad num1, unsigned long num2);

Returns

A pointer to num1.
num1 the uquad result (num1 - num2)

Notes

This function subtracts the unsigned long value in num2 from the uquad value in num1. A pointer is returned to num1, which contains the uquad result.

	{
	   uquad num1;
	   _mov_uql(num1,1234567890);
	   _sub_uql(num1,1234567880);/* num1 = 10 */
	   ...
	}

	#include <inline.h>
	{
	   uquad num1;
	   ...
	   mov ax,0x02D2
	   mov dx,0x4992/* DX;AX = num2 = 0x499202D2 */
	   lea di,num1	    /* DI = offset of num1 */
	   mov_uql();
	   mov ax,0x02C8/* AX = AX - 10 */
	   sub_uql();	/* num = 10 */
	    jncs_uql_100    
	   ... 	 	/* handle overflow */
	s_uql_100:
	   ...
	}

_sub_uqq

Descrip

Subtracts one uquad from another uquad.

Syntax

#include <imath.h>
quadptr _sub_uqq(uquad num1, uquad num2);

Returns

A pointer to num1.
num1 the uquad result (num1 - num2)

Notes

This function subtracts the uquad value in num2 from the uquad value in num1. A pointer is returned to num1, which contains the uquad result.

This function may be used interchangeably with _sub_qq (_sub_uqq and _sub_qq are two different names for the same function).

	{
	   uquad num1, num2;
	   _mov_uql(num1,1999999999);
	   _mov_uql(num2,1234567890);
	   _sub_uqq(num1,num2);    /* num1 = 765432109 */
	   ...
	}

	#include <inline.h>
	{
	   uquad num1, num2;
	   unsigned long num_a = 1999999999, num_b = 1234567890;
	... 
	lea di,num1	   /* DI = offset of num1 */
	lea si,num2	   /* SI = offset of num2 */
	mov ax,word ptr num_a
	mov dx,word ptr num_a+2/* DX;AX = 1999999999 */
	mov_uql();	 	/* set num1 value */
	mov ax,word ptr num_b
	mov ax,word ptr num_b+2/* DX;AX = 1234567890 */
	xchgdi,si	 	/* DI = offset of num2 */
	mov_uql();	 	/* set num2 value */
	xchgdi,si	 	/* DI = offset of num1 */
	sub_uqq();	 	/* num1 = 765432109 */
	 jncs_uqq_100
	...    	 	/* handle overflow */
	s_uqq_100:
	...
	}