summaryrefslogtreecommitdiffstats
path: root/ml/dlib/dlib/bigint/bigint_kernel_c.h
diff options
context:
space:
mode:
Diffstat (limited to 'ml/dlib/dlib/bigint/bigint_kernel_c.h')
-rw-r--r--ml/dlib/dlib/bigint/bigint_kernel_c.h1141
1 files changed, 1141 insertions, 0 deletions
diff --git a/ml/dlib/dlib/bigint/bigint_kernel_c.h b/ml/dlib/dlib/bigint/bigint_kernel_c.h
new file mode 100644
index 000000000..954869a38
--- /dev/null
+++ b/ml/dlib/dlib/bigint/bigint_kernel_c.h
@@ -0,0 +1,1141 @@
+// Copyright (C) 2003 Davis E. King (davis@dlib.net)
+// License: Boost Software License See LICENSE.txt for the full license.
+#ifndef DLIB_BIGINT_KERNEl_C_
+#define DLIB_BIGINT_KERNEl_C_
+
+#include "bigint_kernel_abstract.h"
+#include "../algs.h"
+#include "../assert.h"
+#include <iostream>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ class bigint_kernel_c
+ {
+ bigint_base data;
+
+ explicit bigint_kernel_c (
+ const bigint_base& item
+ ) : data(item) {}
+
+ public:
+
+
+ bigint_kernel_c (
+ );
+
+ bigint_kernel_c (
+ uint32 value
+ );
+
+ bigint_kernel_c (
+ const bigint_kernel_c<bigint_base>& item
+ );
+
+ ~bigint_kernel_c (
+ );
+
+ const bigint_kernel_c<bigint_base> operator+ (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const;
+
+ bigint_kernel_c<bigint_base>& operator+= (
+ const bigint_kernel_c<bigint_base>& rhs
+ );
+
+ const bigint_kernel_c<bigint_base> operator- (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const;
+ bigint_kernel_c<bigint_base>& operator-= (
+ const bigint_kernel_c<bigint_base>& rhs
+ );
+
+ const bigint_kernel_c<bigint_base> operator* (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const;
+
+ bigint_kernel_c<bigint_base>& operator*= (
+ const bigint_kernel_c<bigint_base>& rhs
+ );
+
+ const bigint_kernel_c<bigint_base> operator/ (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const;
+
+ bigint_kernel_c<bigint_base>& operator/= (
+ const bigint_kernel_c<bigint_base>& rhs
+ );
+
+ const bigint_kernel_c<bigint_base> operator% (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const;
+
+ bigint_kernel_c<bigint_base>& operator%= (
+ const bigint_kernel_c<bigint_base>& rhs
+ );
+
+ bool operator < (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const;
+
+ bool operator == (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const;
+
+ bigint_kernel_c<bigint_base>& operator= (
+ const bigint_kernel_c<bigint_base>& rhs
+ );
+
+ template <typename T>
+ friend std::ostream& operator<< (
+ std::ostream& out,
+ const bigint_kernel_c<T>& rhs
+ );
+
+ template <typename T>
+ friend std::istream& operator>> (
+ std::istream& in,
+ bigint_kernel_c<T>& rhs
+ );
+
+ bigint_kernel_c<bigint_base>& operator++ (
+ );
+
+ const bigint_kernel_c<bigint_base> operator++ (
+ int
+ );
+
+ bigint_kernel_c<bigint_base>& operator-- (
+ );
+
+ const bigint_kernel_c<bigint_base> operator-- (
+ int
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator+ (
+ uint16 lhs,
+ const bigint_kernel_c<T>& rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator+ (
+ const bigint_kernel_c<T>& lhs,
+ uint16 rhs
+ );
+
+ bigint_kernel_c<bigint_base>& operator+= (
+ uint16 rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator- (
+ uint16 lhs,
+ const bigint_kernel_c<T>& rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator- (
+ const bigint_kernel_c<T>& lhs,
+ uint16 rhs
+ );
+
+ bigint_kernel_c<bigint_base>& operator-= (
+ uint16 rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator* (
+ uint16 lhs,
+ const bigint_kernel_c<T>& rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator* (
+ const bigint_kernel_c<T>& lhs,
+ uint16 rhs
+ );
+
+ bigint_kernel_c<bigint_base>& operator*= (
+ uint16 rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator/ (
+ uint16 lhs,
+ const bigint_kernel_c<T>& rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator/ (
+ const bigint_kernel_c<T>& lhs,
+ uint16 rhs
+ );
+
+ bigint_kernel_c<bigint_base>& operator/= (
+ uint16 rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator% (
+ uint16 lhs,
+ const bigint_kernel_c<T>& rhs
+ );
+
+ template <typename T>
+ friend const bigint_kernel_c<T> operator% (
+ const bigint_kernel_c<T>& lhs,
+ uint16 rhs
+ );
+
+ bigint_kernel_c<bigint_base>& operator%= (
+ uint16 rhs
+ );
+
+ template <typename T>
+ friend bool operator < (
+ uint16 lhs,
+ const bigint_kernel_c<T>& rhs
+ );
+
+ template <typename T>
+ friend bool operator < (
+ const bigint_kernel_c<T>& lhs,
+ uint16 rhs
+ );
+
+ template <typename T>
+ friend bool operator == (
+ const bigint_kernel_c<T>& lhs,
+ uint16 rhs
+ );
+
+ template <typename T>
+ friend bool operator == (
+ uint16 lhs,
+ const bigint_kernel_c<T>& rhs
+ );
+
+ bigint_kernel_c<bigint_base>& operator= (
+ uint16 rhs
+ );
+
+
+ void swap (
+ bigint_kernel_c<bigint_base>& item
+ ) { data.swap(item.data); }
+
+ };
+
+ template <
+ typename bigint_base
+ >
+ void swap (
+ bigint_kernel_c<bigint_base>& a,
+ bigint_kernel_c<bigint_base>& b
+ ) { a.swap(b); }
+
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ inline void serialize (
+ const bigint_kernel_c<bigint_base>& item,
+ std::ostream& out
+ )
+ {
+ std::ios::fmtflags oldflags = out.flags();
+ out.flags();
+ out << item << ' ';
+ out.flags(oldflags);
+ if (!out) throw serialization_error("Error serializing object of type bigint_kernel_c");
+ }
+
+ template <
+ typename bigint_base
+ >
+ inline void deserialize (
+ bigint_kernel_c<bigint_base>& item,
+ std::istream& in
+ )
+ {
+ std::ios::fmtflags oldflags = in.flags();
+ in.flags();
+ in >> item; in.flags(oldflags);
+ if (in.get() != ' ')
+ {
+ item = 0;
+ throw serialization_error("Error deserializing object of type bigint_kernel_c");
+ }
+ }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+ // member function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>::
+ bigint_kernel_c (
+ )
+ {}
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>::
+ bigint_kernel_c (
+ uint32 value
+ ) :
+ data(value)
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( value <= 0xFFFFFFFF ,
+ "\tbigint::bigint(uint16)"
+ << "\n\t value must be <= (2^32)-1"
+ << "\n\tthis: " << this
+ << "\n\tvalue: " << value
+ );
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>::
+ bigint_kernel_c (
+ const bigint_kernel_c<bigint_base>& item
+ ) :
+ data(item.data)
+ {}
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>::
+ ~bigint_kernel_c (
+ )
+ {}
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+ operator+ (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const
+ {
+ return bigint_kernel_c<bigint_base>(data + rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator+= (
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ data += rhs.data;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+ operator- (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(*this < rhs),
+ "\tconst bigint bigint::operator-(const bigint&)"
+ << "\n\t *this should not be less than rhs"
+ << "\n\tthis: " << this
+ << "\n\t*this: " << *this
+ << "\n\trhs: " << rhs
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(data-rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator-= (
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(*this < rhs),
+ "\tbigint& bigint::operator-=(const bigint&)"
+ << "\n\t *this should not be less than rhs"
+ << "\n\tthis: " << this
+ << "\n\t*this: " << *this
+ << "\n\trhs: " << rhs
+ );
+
+ // call the real function
+ data -= rhs.data;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+ operator* (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const
+ {
+ return bigint_kernel_c<bigint_base>(data * rhs.data );
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator*= (
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ data *= rhs.data;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+ operator/ (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const
+ {
+ //make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0),
+ "\tconst bigint bigint::operator/(const bigint&)"
+ << "\n\t can't divide by zero"
+ << "\n\tthis: " << this
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(data/rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator/= (
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0),
+ "\tbigint& bigint::operator/=(const bigint&)"
+ << "\n\t can't divide by zero"
+ << "\n\tthis: " << this
+ );
+
+ // call the real function
+ data /= rhs.data;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+ operator% (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0),
+ "\tconst bigint bigint::operator%(const bigint&)"
+ << "\n\t can't divide by zero"
+ << "\n\tthis: " << this
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(data%rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator%= (
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0),
+ "\tbigint& bigint::operator%=(const bigint&)"
+ << "\n\t can't divide by zero"
+ << "\n\tthis: " << this
+ );
+
+ // call the real function
+ data %= rhs.data;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bool bigint_kernel_c<bigint_base>::
+ operator < (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const
+ {
+ return data < rhs.data;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bool bigint_kernel_c<bigint_base>::
+ operator == (
+ const bigint_kernel_c<bigint_base>& rhs
+ ) const
+ {
+ return data == rhs.data;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator= (
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ data = rhs.data;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ std::ostream& operator<< (
+ std::ostream& out,
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ out << rhs.data;
+ return out;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ std::istream& operator>> (
+ std::istream& in,
+ bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ in >> rhs.data;
+ return in;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator++ (
+ )
+ {
+ ++data;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+ operator++ (
+ int
+ )
+ {
+ return bigint_kernel_c<bigint_base>(data++);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator-- (
+ )
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(*this == 0),
+ "\tbigint& bigint::operator--()"
+ << "\n\t *this to subtract from *this it must not be zero to begin with"
+ << "\n\tthis: " << this
+ );
+
+ // call the real function
+ --data;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+ operator-- (
+ int
+ )
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(*this == 0),
+ "\tconst bigint bigint::operator--(int)"
+ << "\n\t *this to subtract from *this it must not be zero to begin with"
+ << "\n\tthis: " << this
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(data--);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator+ (
+ uint16 l,
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ uint32 lhs = l;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( lhs <= 65535,
+ "\tconst bigint operator+(uint16, const bigint&)"
+ << "\n\t lhs must be <= 65535"
+ << "\n\trhs: " << rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ return bigint_kernel_c<bigint_base>(static_cast<uint16>(lhs)+rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator+ (
+ const bigint_kernel_c<bigint_base>& lhs,
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( rhs <= 65535,
+ "\tconst bigint operator+(const bigint&, uint16)"
+ << "\n\t rhs must be <= 65535"
+ << "\n\trhs: " << rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ return bigint_kernel_c<bigint_base>(lhs.data+static_cast<uint16>(rhs));
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator+= (
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( rhs <= 65535,
+ "\tbigint& bigint::operator+=(uint16)"
+ << "\n\t rhs must be <= 65535"
+ << "\n\tthis: " << this
+ << "\n\t*this: " << *this
+ << "\n\trhs: " << rhs
+ );
+
+ data += rhs;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator- (
+ uint16 l,
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ uint32 lhs = l;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(static_cast<uint16>(lhs) < rhs) && lhs <= 65535,
+ "\tconst bigint operator-(uint16,const bigint&)"
+ << "\n\t lhs must be greater than or equal to rhs and lhs <= 65535"
+ << "\n\tlhs: " << lhs
+ << "\n\trhs: " << rhs
+ << "\n\t&lhs: " << &lhs
+ << "\n\t&rhs: " << &rhs
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(static_cast<uint16>(lhs)-rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator- (
+ const bigint_kernel_c<bigint_base>& lhs,
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(lhs < static_cast<uint16>(rhs)) && rhs <= 65535,
+ "\tconst bigint operator-(const bigint&,uint16)"
+ << "\n\t lhs must be greater than or equal to rhs and rhs <= 65535"
+ << "\n\tlhs: " << lhs
+ << "\n\trhs: " << rhs
+ << "\n\t&lhs: " << &lhs
+ << "\n\t&rhs: " << &rhs
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(lhs.data-static_cast<uint16>(rhs));
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator-= (
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(*this < static_cast<uint16>(rhs)) && rhs <= 65535,
+ "\tbigint& bigint::operator-=(uint16)"
+ << "\n\t *this must not be less than rhs and rhs <= 65535"
+ << "\n\tthis: " << this
+ << "\n\t*this: " << *this
+ << "\n\trhs: " << rhs
+ );
+
+ // call the real function
+ data -= static_cast<uint16>(rhs);
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator* (
+ uint16 l,
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ uint32 lhs = l;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( lhs <= 65535,
+ "\tconst bigint operator*(uint16, const bigint&)"
+ << "\n\t lhs must be <= 65535"
+ << "\n\trhs: " << rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ return bigint_kernel_c<bigint_base>(lhs*rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator* (
+ const bigint_kernel_c<bigint_base>& lhs,
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( rhs <= 65535,
+ "\tconst bigint operator*(const bigint&, uint16)"
+ << "\n\t rhs must be <= 65535"
+ << "\n\trhs: " << rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ return bigint_kernel_c<bigint_base>(lhs.data*rhs);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator*= (
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( rhs <= 65535,
+ "\t bigint bigint::operator*=(uint16)"
+ << "\n\t rhs must be <= 65535"
+ << "\n\tthis: " << this
+ << "\n\t*this: " << *this
+ << "\n\trhs: " << rhs
+ );
+
+ data *= static_cast<uint16>(rhs);
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator/ (
+ uint16 l,
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ uint32 lhs = l;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0) && lhs <= 65535,
+ "\tconst bigint operator/(uint16,const bigint&)"
+ << "\n\t you can't divide by zero and lhs <= 65535"
+ << "\n\t&lhs: " << &lhs
+ << "\n\t&rhs: " << &rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(lhs/rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator/ (
+ const bigint_kernel_c<bigint_base>& lhs,
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0) && rhs <= 65535,
+ "\tconst bigint operator/(const bigint&,uint16)"
+ << "\n\t you can't divide by zero and rhs <= 65535"
+ << "\n\t&lhs: " << &lhs
+ << "\n\t&rhs: " << &rhs
+ << "\n\trhs: " << rhs
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(lhs.data/static_cast<uint16>(rhs));
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator/= (
+ uint16 rhs
+ )
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0) && static_cast<uint32>(rhs) <= 65535,
+ "\tbigint& bigint::operator/=(uint16)"
+ << "\n\t you can't divide by zero and rhs must be <= 65535"
+ << "\n\tthis: " << this
+ << "\n\trhs: " << rhs
+ );
+
+ // call the real function
+ data /= rhs;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator% (
+ uint16 lhs,
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0) && static_cast<uint32>(lhs) <= 65535,
+ "\tconst bigint operator%(uint16,const bigint&)"
+ << "\n\t you can't divide by zero and lhs must be <= 65535"
+ << "\n\t&lhs: " << &lhs
+ << "\n\t&rhs: " << &rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(lhs%rhs.data);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ const bigint_kernel_c<bigint_base> operator% (
+ const bigint_kernel_c<bigint_base>& lhs,
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0) && rhs <= 65535,
+ "\tconst bigint operator%(const bigint&,uint16)"
+ << "\n\t you can't divide by zero and rhs must be <= 65535"
+ << "\n\t&lhs: " << &lhs
+ << "\n\t&rhs: " << &rhs
+ << "\n\trhs: " << rhs
+ );
+
+ // call the real function
+ return bigint_kernel_c<bigint_base>(lhs.data%static_cast<uint16>(rhs));
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator%= (
+ uint16 r
+ )
+ {
+
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( !(rhs == 0) && rhs <= 65535,
+ "\tbigint& bigint::operator%=(uint16)"
+ << "\n\t you can't divide by zero and rhs must be <= 65535"
+ << "\n\tthis: " << this
+ << "\n\trhs: " << rhs
+ );
+
+ // call the real function
+ data %= rhs;
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bool operator < (
+ uint16 l,
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ uint32 lhs = l;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( lhs <= 65535,
+ "\tbool operator<(uint16, const bigint&)"
+ << "\n\t lhs must be <= 65535"
+ << "\n\trhs: " << rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ return static_cast<uint16>(lhs) < rhs.data;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bool operator < (
+ const bigint_kernel_c<bigint_base>& lhs,
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( rhs <= 65535,
+ "\tbool operator<(const bigint&, uint16)"
+ << "\n\t rhs must be <= 65535"
+ << "\n\trhs: " << rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ return lhs.data < static_cast<uint16>(rhs);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bool operator == (
+ const bigint_kernel_c<bigint_base>& lhs,
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( rhs <= 65535,
+ "\tbool operator==(const bigint&, uint16)"
+ << "\n\t rhs must be <= 65535"
+ << "\n\trhs: " << rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ return lhs.data == static_cast<uint16>(rhs);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bool operator == (
+ uint16 l,
+ const bigint_kernel_c<bigint_base>& rhs
+ )
+ {
+ uint32 lhs = l;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( lhs <= 65535,
+ "\tbool operator==(uint16, const bigint&)"
+ << "\n\t lhs must be <= 65535"
+ << "\n\trhs: " << rhs
+ << "\n\tlhs: " << lhs
+ );
+
+ return static_cast<uint16>(lhs) == rhs.data;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename bigint_base
+ >
+ bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+ operator= (
+ uint16 r
+ )
+ {
+ uint32 rhs = r;
+ // make sure requires clause is not broken
+ DLIB_CASSERT( rhs <= 65535,
+ "\tbigint bigint::operator=(uint16)"
+ << "\n\t rhs must be <= 65535"
+ << "\n\t*this: " << *this
+ << "\n\tthis: " << this
+ << "\n\tlhs: " << rhs
+ );
+
+ data = static_cast<uint16>(rhs);
+ return *this;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template < typename bigint_base >
+ inline bool operator> (const bigint_kernel_c<bigint_base>& a, const bigint_kernel_c<bigint_base>& b) { return b < a; }
+ template < typename bigint_base >
+ inline bool operator!= (const bigint_kernel_c<bigint_base>& a, const bigint_kernel_c<bigint_base>& b) { return !(a == b); }
+ template < typename bigint_base >
+ inline bool operator<= (const bigint_kernel_c<bigint_base>& a, const bigint_kernel_c<bigint_base>& b) { return !(b < a); }
+ template < typename bigint_base >
+ inline bool operator>= (const bigint_kernel_c<bigint_base>& a, const bigint_kernel_c<bigint_base>& b) { return !(a < b); }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_BIGINT_KERNEl_C_
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-28 14:11:36 +0000