ZF/OpenFace
1
0
Fork 0
mirror of https://gitcode.com/gh_mirrors/ope/OpenFace.git synced 2026-05-15 11:47:50 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
ff2075ee4836b3f0afa33e9cd059ff272f97e586
OpenFace/lib/3rdParty/dlib/include/dlib/bigint/bigint_kernel_c.h
unknown 57e58a6949 Master commit of OpenFace.
2016-04-28 15:40:36 -04:00

1131 lines
31 KiB
C++
Raw Blame History

// 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;
}
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_BIGINT_KERNEl_C_
Reference in New Issue View Git Blame Copy Permalink