====== Namespace math ======

This namespace is used to provide support functions for math operations.

===== Functions =====

<code act>
template<pint Worig, Wnew> function sign_extend (int<Worig> x) : int<Wnew>;
</code>

This function takes an integer ''x'' of width ''Worig'', and sign extends its most significant bit to return a result that has width ''Wnew''. It assumes that ''Wnew'' is at least ''Worig.''


<code act>
template<pint Worig, Wnew> function zero_extend (int<Worig> x) : int<Wnew>;
</code>

This function takes an integer ''x'' of width ''Worig'', and zero extends it to return a result that has width ''Wnew''. It assumes that ''Wnew'' is at least ''Worig.''

===== Fixed point data type =====

The standard math library has a fixed point data type.

<code act>
export template <pint A, B> deftype fixpoint(int<A+B> x);
</code>

This datatype uses the standard Q(A,B) fixed point format, where A bits are used for the integer part and B bits are used for the fractional part. This datatype defines operators for addition, subtraction, multiplication, division, as well as comparison operators.

The following code fragment initializes the fixed point value ''x'' to 5.25. ''x.const(5.25)'' returns a parameterized integer corresponding to translating the real number 5.25 to the fixed point representation used by ''x''. Note that ''x.const()'' returns a ''pint'', so it is limited to 64 bits. ''x.set()'' is a macro that takes an integer of bitwidth (A+B) and sets ''x'' to the specified fixed point number.
<code act>
math::fixpoint<8,3> x;
...
chp {
    x.set(x.const(5.25));
    ...
}
</code>
Other ways to initialize ''x'' to the fixed point number corresponding to the integer representation ''0x0f'' (which corresponds to 1.875 for Q(8,3)) are:
<code act>
...
chp {
   x.x := 0x0f;
   ...
   x.set(0x0f);
   ...
}
</code>

For debugging purposes, two macros are also provided for displaying the value of a fixed point number. The ''log()'' macro just displays the number using the ''log()'' statement, while the ''log_p()'' displays it without a new line.
<code act>
chp { 
   ...
   x.log();
   ...
}
</code>   



===== Namespace math::fxp =====

==== Functions ====

The ''math::fxp'' namespace contains simple definitions for fixed-point arithmetic functions. Functions take two parameters ''A'' and ''B'', and integers use the standard Q-format where the representation Q(A,B) corresponds to A digits for the integer part and B digits for the fractional part. The representation uses 2's complement for negative
numbers, so addition and subtraction are the same for signed and unsigned arithmetic.

<code act>
template<pint A,B> function add (int<A+B> x, y) : int<A+B>;
</code>
This returns the sum of two Q(A,B) numbers ''x'' and ''y''.

<code act>
template<pint A,B> function sub (int<A+B> x, y) : int<A+B>;
</code>
This returns the difference of two Q(A,B) numbers ''x'' and ''y''.

<code act>
template<pint A,B> function multu (int<A+B> x, y) : int<A+B>;
</code>
This returns the unsigned product of two Q(A,B) numbers ''x'' and ''y''.

<code act>
template<pint A,B> function divu (int<A+B> x, y) : int<A+B>;
</code>
This returns the unsigned division result ''x/y'' of two Q(A,B) numbers ''x'' and ''y''.

<code act>
template<pint A,B> function mults (int<A+B> x, y) : int<A+B>;
</code>
This returns the signed product of two Q(A,B) numbers ''x'' and ''y''.

<code act>
template<pint A,B> function divs (int<A+B> x, y) : int<A+B>;
</code>
This returns the signed division result ''x/y'' of two Q(A,B) numbers ''x'' and ''y''.

<code act>
template<pint A,B> function uminus (int<A+B> x) : int<A+B>;
</code>
This returns the negated value of a signed Q(A,B) number ''x''.

<code act>
template<pint A,B> function positive (int<A+B> x) : bool;
</code>
This is true if the fixed point number is positive (greater than zero), and false otherwise.

<code act>
template<pint A,B> function negative (int<A+B> x) : bool;
</code>
This is true if the fixed point number is negative, and false otherwise

<code act>
template<pint A,B> function le(int<A+B> x, y) : bool;
</code>
This tests if the value in ''x'' is less than or equal to ''y''.

<code act>
function conv_to_fxp(pint A, B; preal v) : pint;
</code>
This can be used to convert a real constant value into its fixed point representation. Note that since ''pint'' values are 64-bit wide (max), this only works when ''A+B'' is at most 64.

These functions are used by the fixed point data type.