[#base_uint-02]
= base_uint
:mrdocs:

Template base class for unsigned big integers.

== Synopsis

Declared in `<arith_uint256.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template<unsigned int BITS>
class base_uint;
----

== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:base_uint-02/2constructor-025.adoc[`base_uint`]         [.small]#[constructor]#
| Constructors
| xref:base_uint-02/operator_assign-0f.adoc[`operator=`] 
| Assignment operators
| xref:base_uint-02/CompareTo.adoc[`CompareTo`] 
| Numeric ordering, treating the value as an unsigned integer rather than a byte blob.
| xref:base_uint-02/EqualTo.adoc[`EqualTo`] 
| Tests whether the value equals a 64‐bit unsigned number.
| xref:base_uint-02/GetHex.adoc[`GetHex`] 
| Hex encoding of the number (with the most significant digits first).
| xref:base_uint-02/GetLow64.adoc[`GetLow64`] 
| Returns the low 64 bits of the value.
| xref:base_uint-02/ToString.adoc[`ToString`] 
| Returns the value as a human‐readable string.
| xref:base_uint-02/bits.adoc[`bits`] 
| Returns the position of the highest bit set plus one, or zero if the value is zero.
| xref:base_uint-02/getdouble.adoc[`getdouble`] 
| Converts the value to a double‐precision floating‐point number.
| xref:base_uint-02/operator_and_eq.adoc[`operator&=`] 
| Applies a bitwise AND with another big integer in place.
| xref:base_uint-02/operator_star_eq-05.adoc[`operator*=`] 
| Multiplication assignment operators
| xref:base_uint-02/operator_inc-092.adoc[`operator++`] 
| Increment operators
| xref:base_uint-02/operator_plus_eq-02.adoc[`operator+=`] 
| Addition assignment operators
| xref:base_uint-02/operator_minus.adoc[`operator‐`] 
| Returns the two's‐complement negation of the value.
| xref:base_uint-02/operator_dec-08.adoc[`operator‐‐`] 
| Decrement operators
| xref:base_uint-02/operator_minus_eq-05.adoc[`operator‐=`] 
| Subtraction assignment operators
| xref:base_uint-02/operator_slash_eq.adoc[`operator/=`] 
| Divides this value by another big integer in place.
| xref:base_uint-02/operator_lshift_eq.adoc[`operator<<=`] 
| Shifts the value left by the given number of bits in place.
| xref:base_uint-02/operator_rshift_eq.adoc[`operator>>=`] 
| Shifts the value right by the given number of bits in place.
| xref:base_uint-02/operator_xor_eq-0a.adoc[`operatorˆ=`] 
| Bitwise exclusive‐or assignment operators
| xref:base_uint-02/operator_or_eq-0a.adoc[`operator|=`] 
| Bitwise disjunction assignment operators
| xref:base_uint-02/operator_bitnot.adoc[`operator~`] 
| Returns the bitwise complement of the value.
| xref:base_uint-02/size.adoc[`size`] 
| Returns the size in bytes of the internal representation.
|===


== Protected Data Members

[cols="1,4"]
|===
| Name| Description
| xref:base_uint-02/pn.adoc[`pn`] 
| Big integer represented with 32‐bit digits, least‐significant first.
|===


== Protected Static Data Members

[cols="1,4"]
|===
| Name| Description
| xref:base_uint-02/WIDTH.adoc[`WIDTH`] 
| Number of 32‐bit digits used to store the value.
|===


== Specializations

[cols="1"]
|===
| Name
| xref:base_uint-0d.adoc[`base_uint<256>`] 
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `xref:operator_eq-0ae.adoc[operator==]`
| Tests whether a big integer equals a 64‐bit value.
| `xref:operator_3way-05a.adoc[operator<=>]`
| Performs a three‐way comparison of two big integers.
| `xref:operator_eq-06d.adoc[operator==]`
| Tests whether two big integers are equal.
| `xref:operator_star-01.adoc[operator*]`
| Returns the product of a big integer and a 32‐bit value.
| `xref:operator_lshift-08.adoc[operator<<]`
| Returns the value shifted left by a number of bits.
| `xref:operator_rshift-02.adoc[operator>>]`
| Returns the value shifted right by a number of bits.
| `xref:operator_xor-00.adoc[operatorˆ]`
| Returns the bitwise XOR of two big integers.
| `xref:operator_bitand-0d.adoc[operator&]`
| Returns the bitwise AND of two big integers.
| `xref:operator_bitor-0b.adoc[operator|]`
| Returns the bitwise OR of two big integers.
| `xref:operator_slash-03.adoc[operator/]`
| Returns the quotient of two big integers.
| `xref:operator_star-03.adoc[operator*]`
| Returns the product of two big integers.
| `xref:operator_minus-08.adoc[operator‐]`
| Returns the difference of two big integers.
| `xref:operator_plus-0fc.adoc[operator+]`
| Returns the sum of two big integers.
|===

== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:operator_bitand-07.adoc[`operator&`]
| Returns the bitwise AND of two big integers.
| xref:operator_star-00.adoc[`operator*`]
| Returns the product of a big integer and a 32‐bit value.
| xref:operator_star-0ee.adoc[`operator*`]
| Returns the product of two big integers.
| xref:operator_plus-0a6.adoc[`operator+`]
| Returns the sum of two big integers.
| xref:operator_minus-07.adoc[`operator‐`]
| Returns the difference of two big integers.
| xref:operator_slash-0e.adoc[`operator/`]
| Returns the quotient of two big integers.
| xref:operator_lshift-07.adoc[`operator<<`]
| Returns the value shifted left by a number of bits.
| xref:operator_3way-00f.adoc[`operator<=>`]
| Performs a three‐way comparison of two big integers.
| xref:operator_eq-007d.adoc[`operator==`]
| Tests whether two big integers are equal.
| xref:operator_eq-050.adoc[`operator==`]
| Tests whether a big integer equals a 64‐bit value.
| xref:operator_rshift-03.adoc[`operator>>`]
| Returns the value shifted right by a number of bits.
| xref:operator_xor-08.adoc[`operatorˆ`]
| Returns the bitwise XOR of two big integers.
| xref:operator_bitor-04.adoc[`operator|`]
| Returns the bitwise OR of two big integers.
|===

== Derived Classes

[cols="1,4"]
|===
| Name| Description
| xref:arith_uint256.adoc[`arith_uint256`] 
| 256‐bit unsigned big integer.
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#