GabrielTofvesson/CryptoCPP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed files not being added

Browse Source
This commit is contained in:
Gabriel Tofvesson 2018-02-27 21:59:19 +01:00
parent a068c34862
commit a9df66c179
5 changed files with 104 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -21,6 +21,7 @@ bld/
[Bb]in/
[Oo]bj/
[Ll]og/
build/
# Visual Studio 2015 cache/options directory
.vs/

24
XMath/BigInteger.cpp
View File

@ -2,14 +2,15 @@
#include "BigInteger.h"
namespace CryptoCPP {
namespace Math {
BIGINT_API BigInteger::BigInteger(int64_t initialValue)
BIGINT_API BigInteger::BigInteger(long long initialValue)
{
data = new std::vector<BYTE>();
// We know how big this should be and we know the size won't change
static const size_t bytes = sizeof(int64_t);
static const size_t bytes = sizeof(initialValue);
for (size_t t = 0; t < bytes; ++t) data->push_back((initialValue >> (t * 8)) & 255);
sign = false;
@ -93,14 +94,14 @@ namespace CryptoCPP {
return create;
}
BIGINT_API BigInteger * BigInteger::operator<<(uint64_t shiftcount) const
BIGINT_API BigInteger * BigInteger::operator<<(size_t shiftcount) const
{
BigInteger* create = new BigInteger(*this);
create->ishl(shiftcount);
return create;
}
BIGINT_API BigInteger * BigInteger::operator>>(uint64_t shiftcount) const
BIGINT_API BigInteger * BigInteger::operator>>(size_t shiftcount) const
{
BigInteger* create = new BigInteger(*this);
create->ishr(shiftcount);
@ -157,13 +158,13 @@ namespace CryptoCPP {
return this;
}
BIGINT_API BigInteger* BigInteger::operator<<=(uint64_t shiftcount)
BIGINT_API BigInteger* BigInteger::operator<<=(size_t shiftcount)
{
ishl(shiftcount);
return this;
}
BIGINT_API BigInteger* BigInteger::operator>>=(uint64_t shiftcount)
BIGINT_API BigInteger* BigInteger::operator>>=(size_t shiftcount)
{
ishr(shiftcount);
return this;
@ -338,7 +339,7 @@ namespace CryptoCPP {
BIGINT_API BigInteger* BigInteger::idiv(const BigInteger & val, bool swaptarget)
{
if (val.is_zero()) throw new std::exception("Divide by zero!");
if (val.is_zero()) throw new std::exception(); // Divide by zero!
BigInteger* rem = new BigInteger(0);
BigInteger quot = BigInteger(0);
@ -403,7 +404,7 @@ namespace CryptoCPP {
for (size_t t = 0; t < data->size(); ++t) (*data)[t] = ~(*data)[t];
}
BIGINT_API void BigInteger::ishl(uint64_t shift)
BIGINT_API void BigInteger::ishl(size_t shift)
{
size_t set = shift / 8;
char sub = shift % 8;
@ -430,7 +431,7 @@ namespace CryptoCPP {
clip_zeroes();
}
BIGINT_API void BigInteger::ishr(uint64_t shift)
BIGINT_API void BigInteger::ishr(size_t shift)
{
size_t offset = shift / 8;
char sub = shift % 8;
@ -491,10 +492,10 @@ namespace CryptoCPP {
return ((l1 > l2 && (!sign == grt)) || ((sign == grt) && l1 < l2)) ? 1 : 0;
}
BIGINT_API char BigInteger::shift_mask(int64_t shift, bool left)
BIGINT_API char BigInteger::shift_mask(size_t shift, bool left)
{
BYTE res = 0;
for (uint64_t i = shift; i > 0; --i) res = left ? (res >> 1) | 128 : (res << 1) | 1;
for (size_t i = shift; i > 0; --i) res = left ? (res >> 1) | 128 : (res << 1) | 1;
return res;
}
@ -548,3 +549,4 @@ namespace CryptoCPP {
}
}

31
XMath/BigInteger.h
View File

@ -2,12 +2,24 @@
#include <vector>
#ifdef BIGINT_API
#if defined(__MINGW32__) || defined(_WIN32)
#if defined(BIGINT_API)
#define BIGINT_API __declspec(dllexport)
#else
#define BIGINT_API __declspec(dllimport)
#endif
#endif
#ifndef BIGINT_API
#if __GNUC__ >= 4
#define BIGINT_API __attribute__ ((visibility ("default")))
#else
#define BIGINT_API
#endif
#endif
#define BYTE unsigned char
@ -16,7 +28,7 @@ namespace CryptoCPP {
class BigInteger
{
public:
BIGINT_API BigInteger(int64_t initialValue);
BIGINT_API BigInteger(long long initialValue);
BIGINT_API BigInteger(const BigInteger& initialvalue);
// These should just create a new bigint and call the internal functions on it
@ -29,8 +41,8 @@ namespace CryptoCPP {
BIGINT_API BigInteger* operator&(const BigInteger& val) const;
BIGINT_API BigInteger* operator|(const BigInteger& val) const;
BIGINT_API BigInteger* operator~() const;
BIGINT_API BigInteger* operator<<(uint64_t shiftcount) const;
BIGINT_API BigInteger* operator>>(uint64_t shiftcount) const;
BIGINT_API BigInteger* operator<<(size_t shiftcount) const;
BIGINT_API BigInteger* operator>>(size_t shiftcount) const;
BIGINT_API BigInteger* operator+=(const BigInteger& val);
BIGINT_API BigInteger* operator-=(const BigInteger& val);
@ -40,8 +52,8 @@ namespace CryptoCPP {
BIGINT_API BigInteger* operator^=(const BigInteger& val);
BIGINT_API BigInteger* operator&=(const BigInteger& val);
BIGINT_API BigInteger* operator|=(const BigInteger& val);
BIGINT_API BigInteger* operator<<=(uint64_t shiftcount);
BIGINT_API BigInteger* operator>>=(uint64_t shiftcount);
BIGINT_API BigInteger* operator<<=(size_t shiftcount);
BIGINT_API BigInteger* operator>>=(size_t shiftcount);
BIGINT_API bool operator<(const BigInteger& val) const;
BIGINT_API bool operator>(const BigInteger& val) const;
@ -66,8 +78,8 @@ namespace CryptoCPP {
BIGINT_API void iand(const BigInteger& val, bool swaptarget);
BIGINT_API void ior(const BigInteger& val, bool swaptarget);
BIGINT_API void inot();
BIGINT_API void ishl(uint64_t shift);
BIGINT_API void ishr(uint64_t shift);
BIGINT_API void ishl(size_t shift);
BIGINT_API void ishr(size_t shift);
BIGINT_API void twos_complement();
BIGINT_API void set_bit(size_t index, bool value);
BIGINT_API void cpy(const BigInteger& val, bool withsign);
@ -75,7 +87,7 @@ namespace CryptoCPP {
BIGINT_API char cmp(const BigInteger& other, bool grt) const;
// Math helper functions
BIGINT_API char shift_mask(int64_t shift, bool left);
BIGINT_API char shift_mask(size_t shift, bool left);
// For sorting and whatnot
BIGINT_API void clip_zeroes();
@ -86,3 +98,4 @@ namespace CryptoCPP {
};
}
}

57
XMath/Matrix.cpp
View File

@ -1,5 +1,6 @@
#define MATRIX_API
#include "Matrix.h"
#include <string.h>
namespace CryptoCPP {
namespace Math {
@ -20,13 +21,13 @@ namespace CryptoCPP {
MATRIX_API long long Vector::at(size_t index) const
{
if (index < 0 || index >= count) throw new std::exception("Index out of bounds");
if (index < 0 || index >= count) throw new std::exception(); // Index out of bounds
return valueSet[index];
}
MATRIX_API long long Vector::at(size_t index, long long newval)
{
if (index < 0 || index >= count) throw new std::exception("Index out of bounds");
if (index < 0 || index >= count) throw new std::exception(); // Index out of bounds
long long l = valueSet[index];
valueSet[index] = newval;
return l;
@ -40,12 +41,12 @@ namespace CryptoCPP {
this->context = context;
}
MATRIX_API const DelegatingFPTR* DelegatingFPTR::operator()(const Vector & input, size_t index) const
MATRIX_API const DelegatingFPTR DelegatingFPTR::operator()(const Vector & input, size_t index) const
{
return (context->*impl)(input, index);
}
MATRIX_API const DelegatingFPTR* DelegatingFPTR::operator()(Vector * input, size_t index) const
MATRIX_API const DelegatingFPTR DelegatingFPTR::operator()(Vector * input, size_t index) const
{
return (context->*point)(input, index);
}
@ -72,59 +73,59 @@ namespace CryptoCPP {
delete[] columns;
}
MATRIX_API const DelegatingFPTR* Matrix::set_row(const Vector & row, size_t rowidx)
MATRIX_API const DelegatingFPTR Matrix::set_row(const Vector & row, size_t rowidx)
{
return set_row_r(row, rowidx);
}
MATRIX_API const DelegatingFPTR* Matrix::set_col(const Vector & col, size_t colidx)
MATRIX_API const DelegatingFPTR Matrix::set_col(const Vector & col, size_t colidx)
{
return set_col_r(col, colidx);
}
MATRIX_API const DelegatingFPTR* Matrix::set_row(Vector * row, size_t rowidx)
MATRIX_API const DelegatingFPTR Matrix::set_row(Vector * row, size_t rowidx)
{
return set_row_p(row, rowidx);
}
MATRIX_API const DelegatingFPTR* Matrix::set_col(Vector * col, size_t colidx)
MATRIX_API const DelegatingFPTR Matrix::set_col(Vector * col, size_t colidx)
{
return set_col_p(col, colidx);
}
MATRIX_API const DelegatingFPTR* Matrix::set_row_r(const Vector & row, size_t rowidx)
MATRIX_API const DelegatingFPTR Matrix::set_row_r(const Vector & row, size_t rowidx)
{
if (rowidx >= height) throw new std::exception("Row index out of bounds");
if (rowidx >= height) throw new std::exception(); // Index out of bounds
size_t min = row.count < width ? row.count : width;
for (size_t t = 0; t < min; ++t) columns[t]->at(rowidx, row.at(t));
return ar;
return *ar;
}
MATRIX_API const DelegatingFPTR* Matrix::set_col_r(const Vector & col, size_t colidx)
MATRIX_API const DelegatingFPTR Matrix::set_col_r(const Vector & col, size_t colidx)
{
if (colidx >= width) throw new std::exception("Column index out of bounds");
if (colidx >= width) throw new std::exception(); // Index out of bounds
size_t min = col.count < height ? col.count : height;
for (size_t t = 0; t < height; ++t) columns[colidx]->at(t, col.at(t));
return ac;
return *ac;
}
MATRIX_API const DelegatingFPTR* Matrix::set_row_p(Vector * row, size_t rowidx)
MATRIX_API const DelegatingFPTR Matrix::set_row_p(Vector * row, size_t rowidx)
{
const DelegatingFPTR * chain = set_row((const Vector&) *row, rowidx);
const DelegatingFPTR chain = set_row((const Vector&) *row, rowidx);
delete row;
return chain;
}
MATRIX_API const DelegatingFPTR* Matrix::set_col_p(Vector * col, size_t colidx)
MATRIX_API const DelegatingFPTR Matrix::set_col_p(Vector * col, size_t colidx)
{
const DelegatingFPTR * chain = set_col((const Vector&) *col, colidx);
const DelegatingFPTR chain = set_col((const Vector&) *col, colidx);
delete col;
return chain;
}
MATRIX_API long long Matrix::set_at(size_t col, size_t row, long long value)
{
if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception("Index out of bounds");
if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception(); // Index out of bounds
return columns[col]->at(row, value);
}
@ -135,7 +136,7 @@ namespace CryptoCPP {
MATRIX_API Vector * Matrix::at_row(size_t index) const
{
if (index < 0 || index >= height) throw new std::exception("Index out of bounds");
if (index < 0 || index >= height) throw new std::exception(); // Index out of bounds
Vector * collect = new Vector(width);
for (size_t t = 0; t < width; ++t)
collect->at(t, columns[t]->at(index));
@ -144,7 +145,7 @@ namespace CryptoCPP {
MATRIX_API Vector * Matrix::at_col(size_t index) const
{
if (index < 0 || index >= width) throw new std::exception("Index out of bounds");
if (index < 0 || index >= width) throw new std::exception(); // Index out of bounds
Vector * collect = new Vector(height);
for (size_t t = 0; t < height; ++t)
collect->at(t, columns[index]->at(t));
@ -153,7 +154,7 @@ namespace CryptoCPP {
MATRIX_API long long Matrix::at(size_t col, size_t row) const
{
if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception("Index out of bounds");
if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception(); // Index out of bounds
return columns[col]->at(row);
}
@ -164,7 +165,7 @@ namespace CryptoCPP {
MATRIX_API Matrix * Matrix::mul(const Matrix & factor) const
{
if (factor.height != width) throw new std::exception("Mismatched dimensions");
if (factor.height != width) throw new std::exception(); // Index out of bounds
Matrix* result = new Matrix(height, factor.width);
for (size_t i = 0; i < factor.width; ++i)
for (size_t j = 0; j < height; ++j)
@ -197,10 +198,10 @@ namespace CryptoCPP {
return mul(scalar);
}
MATRIX_API Matrix * Matrix::minor(size_t row, size_t col) const
MATRIX_API Matrix * Matrix::get_minor(size_t row, size_t col) const
{
if (height == 0 || width == 0) return new Matrix(0, 0);
if (row >= height || col >= width) throw new std::exception("Index out of bounds");
if (row >= height || col >= width) throw new std::exception(); // Index out of bounds
Matrix* result = new Matrix(height - 1, width - 1);
for (size_t i = 0; i < width; ++i) {
if (i == col) continue;
@ -215,8 +216,8 @@ namespace CryptoCPP {
MATRIX_API long long Matrix::det() const
{
// Matrix safety checks
if (height != width) throw new std::exception("Matrix must be square to compute the determinant");
if (!height) throw new std::exception("Zero-matrix does not have a determinant");
if (height != width) throw new std::exception(); // Only square matrices have determinants
if (!height) throw new std::exception(); // Zero-matrix doesn't have a determinant
// Compute determinant for 1x1 matrix
if (height == 1) return columns[0]->at(0);
@ -224,7 +225,7 @@ namespace CryptoCPP {
// Compute determinant for higher-order matrices
long long result = 0;
for (size_t t = 0; t < width; ++t) {
Matrix * smaller = minor(0, t); // Compute minor
Matrix * smaller = get_minor(0, t); // Compute minor
result += smaller->det() * columns[t]->at(0) * (long long)((t % 2) ? -1 : 1); // Compute partial determinant for the given minor
delete smaller; // Delete allocated minor
}

42
XMath/Matrix.h
View File

@ -2,12 +2,25 @@
#include <vector>
#ifdef MATRIX_API
#if defined(__MINGW32__) || defined(_WIN32)
#if defined(MATRIX_API)
#define MATRIX_API __declspec(dllexport)
#else
#define MATRIX_API __declspec(dllimport)
#endif
#endif
#ifndef MATRIX_API
#if __GNUC__ >= 4
#define MATRIX_API __attribute__ ((visibility ("default")))
#else
#define MATRIX_API
#endif
#endif
#define WITH ->operator()
namespace CryptoCPP {
@ -32,16 +45,15 @@ namespace CryptoCPP {
class DelegatingFPTR;
typedef const DelegatingFPTR*(Matrix::*Delegate)(const Vector & input, size_t at);
typedef const DelegatingFPTR*(Matrix::*PDelegate)(const Vector * input, size_t at);
typedef const DelegatingFPTR(Matrix::*Delegate)(const Vector & input, size_t at);
typedef const DelegatingFPTR(Matrix::*PDelegate)(const Vector * input, size_t at);
class DelegatingFPTR {
public:
DelegatingFPTR(Delegate impl, PDelegate point, Matrix* context);
MATRIX_API const DelegatingFPTR* operator()(const Vector & input, size_t index) const;
MATRIX_API const DelegatingFPTR* operator()(Vector * input, size_t index) const;
MATRIX_API const DelegatingFPTR operator()(const Vector & input, size_t index) const;
MATRIX_API const DelegatingFPTR operator()(Vector * input, size_t index) const;
protected:
Delegate impl;
PDelegate point;
@ -55,15 +67,15 @@ namespace CryptoCPP {
MATRIX_API Matrix(const Matrix & copy);
MATRIX_API ~Matrix();
MATRIX_API const DelegatingFPTR* set_row(const Vector & row, size_t rowidx);
MATRIX_API const DelegatingFPTR* set_col(const Vector & col, size_t colidx);
MATRIX_API const DelegatingFPTR* set_row(Vector * row, size_t rowidx);
MATRIX_API const DelegatingFPTR* set_col(Vector * col, size_t colidx);
MATRIX_API const DelegatingFPTR set_row(const Vector & row, size_t rowidx);
MATRIX_API const DelegatingFPTR set_col(const Vector & col, size_t colidx);
MATRIX_API const DelegatingFPTR set_row(Vector * row, size_t rowidx);
MATRIX_API const DelegatingFPTR set_col(Vector * col, size_t colidx);
MATRIX_API const DelegatingFPTR* set_row_r(const Vector & row, size_t rowidx);
MATRIX_API const DelegatingFPTR* set_col_r(const Vector & col, size_t colidx);
MATRIX_API const DelegatingFPTR* set_row_p(Vector * row, size_t rowidx);
MATRIX_API const DelegatingFPTR* set_col_p(Vector * col, size_t colidx);
MATRIX_API const DelegatingFPTR set_row_r(const Vector & row, size_t rowidx);
MATRIX_API const DelegatingFPTR set_col_r(const Vector & col, size_t colidx);
MATRIX_API const DelegatingFPTR set_row_p(Vector * row, size_t rowidx);
MATRIX_API const DelegatingFPTR set_col_p(Vector * col, size_t colidx);
MATRIX_API long long set_at(size_t col, size_t row, long long value);
MATRIX_API long long set_at(size_t index, bool rowMajor, long long value);
@ -79,7 +91,7 @@ namespace CryptoCPP {
MATRIX_API Matrix* operator*(const Matrix * factor) const;
MATRIX_API Matrix* operator*(long long scalar) const;
MATRIX_API Matrix* minor(size_t row, size_t col) const;
MATRIX_API Matrix* get_minor(size_t row, size_t col) const;
MATRIX_API long long det() const;
protected: