sunwen/Aurora
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make aurora from Double to float

Browse Source
This commit is contained in:
kradchen
2023-10-08 15:58:43 +08:00
parent d915f33264
commit 8167775d38
13 changed files with 650 additions and 803 deletions
Download Patch File Download Diff File Expand all files Collapse all files

316
src/Function1D.cpp
View File

@@ -28,26 +28,26 @@ namespace {
const int COMPLEX_STRIDE = 2;
const int REAL_STRIDE = 1;
const int SAME_STRIDE = 1;
const double VALUE_ONE = 1.0;
const float VALUE_ONE = 1.0;
const ushort CONVERT_AND_VALUE = 15;
const ushort CONVERT_AND_VALUE_2 = 2047;
const ushort CONVERT_MUL_VALUE = 2048;
uint CONVERT_ADD_VALUE = UINT32_MAX - 4095;
inline void convertValue(double aValue ,double* des){
double value = aValue;
inline void convertValue(float aValue ,float* des){
float value = aValue;
ushort *exponentPtr = (ushort *)&value;
exponentPtr[0] = (exponentPtr[0] >> 11) & CONVERT_AND_VALUE;
exponentPtr[1] = (exponentPtr[1] >> 11) & CONVERT_AND_VALUE;
exponentPtr[2] = (exponentPtr[2] >> 11) & CONVERT_AND_VALUE;
exponentPtr[3] = (exponentPtr[3] >> 11) & CONVERT_AND_VALUE;
double signValue = aValue;
float signValue = aValue;
short *signPtr = (short *)&signValue;
uint sign_bit[4] = {
(uint)(signPtr[0] < 0 ? 1 : 0), (uint)(signPtr[1] < 0 ? 1 : 0),
(uint)(signPtr[2] < 0 ? 1 : 0), (uint)(signPtr[3] < 0 ? 1 : 0)};
double fraction3Value = aValue;
float fraction3Value = aValue;
ushort *fraction3Ptr = (ushort *)&fraction3Value;
fraction3Ptr[0] &= CONVERT_AND_VALUE_2;
fraction3Ptr[1] &= CONVERT_AND_VALUE_2;
@@ -83,7 +83,7 @@ namespace {
}
inline void convertValue2(short* aValue ,double* des){
inline void convertValue2(short* aValue ,float* des){
ushort exponentPtr[4] = {(ushort)aValue[0],(ushort)aValue[1],(ushort)aValue[2],(ushort)aValue[3]};
exponentPtr[0] = (exponentPtr[0] >> 11) & CONVERT_AND_VALUE;
exponentPtr[1] = (exponentPtr[1] >> 11) & CONVERT_AND_VALUE;
@@ -171,9 +171,9 @@ Aurora::Matrix Aurora::complex(const Aurora::Matrix &matrix) {
return matrix;
}
auto output = malloc(matrix.getDataSize() ,true);
memset(output, 0, (matrix.getDataSize() * sizeof(std::complex<double>)));
cblas_dcopy(matrix.getDataSize(), matrix.getData(), REAL_STRIDE, (double *) output, COMPLEX_STRIDE);
return Aurora::Matrix::New((double *) output, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2),
memset(output, 0, (matrix.getDataSize() * sizeof(std::complex<float>)));
cblas_scopy(matrix.getDataSize(), matrix.getData(), REAL_STRIDE, (float *) output, COMPLEX_STRIDE);
return Aurora::Matrix::New((float *) output, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2),
Complex);
}
@@ -182,10 +182,10 @@ Aurora::Matrix Aurora::real(const Aurora::Matrix &matrix) {
std::cerr<<"real only support complex value type"<<std::endl;
return matrix;
}
auto output = (double *) malloc(matrix.getDataSize());
memset(output, 0, (matrix.getDataSize() * sizeof(double)));
cblas_dcopy(matrix.getDataSize(), matrix.getData(),COMPLEX_STRIDE , (double *) output, REAL_STRIDE);
return Aurora::Matrix::New((double *) output, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2));
auto output = (float *) malloc(matrix.getDataSize());
memset(output, 0, (matrix.getDataSize() * sizeof(float)));
cblas_scopy(matrix.getDataSize(), matrix.getData(),COMPLEX_STRIDE , (float *) output, REAL_STRIDE);
return Aurora::Matrix::New((float *) output, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2));
}
Aurora::Matrix Aurora::imag(const Aurora::Matrix &matrix) {
@@ -194,28 +194,28 @@ Aurora::Matrix Aurora::imag(const Aurora::Matrix &matrix) {
return matrix;
}
auto output = malloc(matrix.getDataSize());
memset(output, 0, (matrix.getDataSize() * sizeof(double)));
cblas_dcopy(matrix.getDataSize(), matrix.getData()+1,COMPLEX_STRIDE , (double *) output, REAL_STRIDE);
return Aurora::Matrix::New((double *) output, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2));
memset(output, 0, (matrix.getDataSize() * sizeof(float)));
cblas_scopy(matrix.getDataSize(), matrix.getData()+1,COMPLEX_STRIDE , (float *) output, REAL_STRIDE);
return Aurora::Matrix::New((float *) output, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2));
}
Aurora::Matrix Aurora::ceil(const Aurora::Matrix &matrix) {
auto output = malloc(matrix.getDataSize());
//for real part
vdCeilI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
vsCeilI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
if (matrix.getValueType() == Complex) {
//for imag part
vdCeilI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, output + 1, SAME_STRIDE);
vsCeilI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, output + 1, SAME_STRIDE);
}
return Aurora::Matrix::New(output, matrix);
}
Aurora::Matrix Aurora::ceil(const Aurora::Matrix &&matrix) {
//for real part
vdCeilI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
vsCeilI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
if (matrix.getValueType() == Complex) {
//for imag part
vdCeilI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, matrix.getData() + 1, SAME_STRIDE);
vsCeilI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, matrix.getData() + 1, SAME_STRIDE);
}
return matrix;
}
@@ -223,20 +223,20 @@ Aurora::Matrix Aurora::ceil(const Aurora::Matrix &&matrix) {
Aurora::Matrix Aurora::round(const Aurora::Matrix &matrix) {
auto output = malloc(matrix.getDataSize());
//for real part
vdRoundI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
vsRoundI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
if (matrix.getValueType() == Complex) {
//for imag part
vdRoundI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, output + 1, SAME_STRIDE);
vsRoundI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, output + 1, SAME_STRIDE);
}
return Aurora::Matrix::New(output, matrix);
}
Aurora::Matrix Aurora::round(const Aurora::Matrix &&matrix) {
//for real part
vdRoundI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
vsRoundI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
if (matrix.getValueType() == Complex) {
//for imag part
vdRoundI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, matrix.getData() + 1, SAME_STRIDE);
vsRoundI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, matrix.getData() + 1, SAME_STRIDE);
}
return matrix;
}
@@ -244,20 +244,20 @@ Aurora::Matrix Aurora::round(const Aurora::Matrix &&matrix) {
Aurora::Matrix Aurora::floor(const Aurora::Matrix &matrix) {
auto output = malloc(matrix.getDataSize());
//for real part
vdFloorI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
vsFloorI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
if (matrix.getValueType() == Complex) {
//for imag part
vdFloorI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, output + 1, SAME_STRIDE);
vsFloorI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, output + 1, SAME_STRIDE);
}
return Aurora::Matrix::New(output, matrix);
}
Aurora::Matrix Aurora::floor(const Aurora::Matrix &&matrix) {
//for real part
vdFloorI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
vsFloorI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
if (matrix.getValueType() == Complex) {
//for imag part
vdFloorI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, matrix.getData() + 1, SAME_STRIDE);
vsFloorI(matrix.getDataSize(), matrix.getData() + 1, SAME_STRIDE, matrix.getData() + 1, SAME_STRIDE);
}
return matrix;
}
@@ -267,7 +267,7 @@ Matrix Aurora::auroraNot(const Matrix& aMatrix){
}
Matrix Aurora::auroraNot(Matrix&& aMatrix){
Eigen::Map<Eigen::VectorXd> v2(aMatrix.getData(), aMatrix.getDataSize());
Eigen::Map<Eigen::VectorXf> v2(aMatrix.getData(), aMatrix.getDataSize());
v2 = (v2.array()>0).select(1,v2);
v2 = (v2.array()<0).select(0,v2);
v2 = v2.array()+1.0;
@@ -279,7 +279,7 @@ Aurora::Matrix Aurora::sqrt(const Aurora::Matrix& matrix) {
if (matrix.getValueType() != Complex) {
auto output = malloc(matrix.getDataSize());
vdSqrtI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
vsSqrtI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
return Aurora::Matrix::New(output, matrix);
}
std::cerr<<"sqrt not support complex"<<std::endl;
@@ -288,7 +288,7 @@ Aurora::Matrix Aurora::sqrt(const Aurora::Matrix& matrix) {
Aurora::Matrix Aurora::sqrt(Aurora::Matrix&& matrix) {
if (matrix.getValueType() != Complex) {
vdSqrtI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
vsSqrtI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
return matrix;
}
std::cerr<<"sqrt not support complex"<<std::endl;
@@ -298,23 +298,23 @@ Aurora::Matrix Aurora::sqrt(Aurora::Matrix&& matrix) {
Aurora::Matrix Aurora::abs(const Aurora::Matrix &matrix) {
auto output = malloc(matrix.getDataSize());
if (matrix.getValueType()==Normal){
vdAbsI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
vsAbsI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, output, SAME_STRIDE);
}
else{
vzAbsI(matrix.getDataSize(), (std::complex<double> *)matrix.getData(), SAME_STRIDE,output, SAME_STRIDE);
vcAbsI(matrix.getDataSize(), (std::complex<float> *)matrix.getData(), SAME_STRIDE,output, SAME_STRIDE);
}
return Aurora::Matrix::New(output, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2));
}
Aurora::Matrix Aurora::abs(Aurora::Matrix&& matrix) {
if (matrix.getValueType()==Normal){
vdAbsI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
vsAbsI(matrix.getDataSize(), matrix.getData(), SAME_STRIDE, matrix.getData(), SAME_STRIDE);
return matrix;
}
//TODO：考虑尝试是不是使用realloc缩短已分配的内存的方式重用matrix
else{
auto output = malloc(matrix.getDataSize());
vzAbsI(matrix.getDataSize(), (std::complex<double> *)matrix.getData(), SAME_STRIDE,output, SAME_STRIDE);
vcAbsI(matrix.getDataSize(), (std::complex<float> *)matrix.getData(), SAME_STRIDE,output, SAME_STRIDE);
return Aurora::Matrix::New(output, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2));
}
@@ -323,7 +323,7 @@ Aurora::Matrix Aurora::abs(Aurora::Matrix&& matrix) {
Aurora::Matrix Aurora::sign(const Aurora::Matrix &matrix) {
if (matrix.getValueType()==Normal){
auto ret = matrix.deepCopy();
Eigen::Map<Eigen::VectorXd> retV(ret.getData(),ret.getDataSize());
Eigen::Map<Eigen::VectorXf> retV(ret.getData(),ret.getDataSize());
retV = retV.array().sign();
return ret;
}
@@ -331,9 +331,9 @@ Aurora::Matrix Aurora::sign(const Aurora::Matrix &matrix) {
//sign(x) = x./abs(x)，前提是 x 为复数。
auto output = malloc(matrix.getDataSize(),true);
Matrix absMatrix = abs(matrix);
vdDivI(matrix.getDataSize(), matrix.getData(),COMPLEX_STRIDE,
vsDivI(matrix.getDataSize(), matrix.getData(),COMPLEX_STRIDE,
absMatrix.getData(), REAL_STRIDE,output,COMPLEX_STRIDE);
vdDivI(matrix.getDataSize(), matrix.getData()+1,COMPLEX_STRIDE,
vsDivI(matrix.getDataSize(), matrix.getData()+1,COMPLEX_STRIDE,
absMatrix.getData(), REAL_STRIDE,output+1,COMPLEX_STRIDE);
return Aurora::Matrix::New(output, matrix);
}
@@ -341,16 +341,16 @@ Aurora::Matrix Aurora::sign(const Aurora::Matrix &matrix) {
Aurora::Matrix Aurora::sign(Aurora::Matrix&& matrix) {
if (matrix.getValueType()==Normal){
Eigen::Map<Eigen::VectorXd> retV(matrix.getData(),matrix.getDataSize());
Eigen::Map<Eigen::VectorXf> retV(matrix.getData(),matrix.getDataSize());
retV = retV.array().sign();
return matrix;
}
else{
//sign(x) = x./abs(x)，前提是 x 为复数。
Matrix absMatrix = abs(matrix);
vdDivI(matrix.getDataSize(), matrix.getData(),COMPLEX_STRIDE,
vsDivI(matrix.getDataSize(), matrix.getData(),COMPLEX_STRIDE,
absMatrix.getData(), REAL_STRIDE,matrix.getData(),COMPLEX_STRIDE);
vdDivI(matrix.getDataSize(), matrix.getData()+1,COMPLEX_STRIDE,
vsDivI(matrix.getDataSize(), matrix.getData()+1,COMPLEX_STRIDE,
absMatrix.getData(), REAL_STRIDE,matrix.getData()+1,COMPLEX_STRIDE);
return matrix;
}
@@ -361,11 +361,11 @@ Matrix Aurora::interp1(const Matrix& aX, const Matrix& aV, const Matrix& aX1, In
const int nx = aX.getDimSize(0);
const int ny = 1;
int nx1 = aX1.getDimSize(0);
std::shared_ptr<double> resultData = std::shared_ptr<double>(Aurora::malloc(nx1), Aurora::free);
std::shared_ptr<float> resultData = std::shared_ptr<float>(Aurora::malloc(nx1), Aurora::free);
std::vector<int> resultInfo = {nx1};
Aurora::Matrix result(resultData, resultInfo);
DFTaskPtr task ;
int status = dfdNewTask1D(&task, nx, aX.getData(), DF_NO_HINT, ny, aV.getData(), DF_NO_HINT);
int status = dfsNewTask1D(&task, nx, aX.getData(), DF_NO_HINT, ny, aV.getData(), DF_NO_HINT);
if (status != DF_STATUS_OK)
{
return Matrix();
@@ -382,20 +382,20 @@ Matrix Aurora::interp1(const Matrix& aX, const Matrix& aV, const Matrix& aX1, In
sorder = DF_PP_LINEAR;
stype = DF_PP_BESSEL;
}
double* scoeffs = Aurora::malloc(ny * (nx-1) * sorder);
status = dfdEditPPSpline1D(task, sorder,DF_PP_NATURAL , DF_BC_NOT_A_KNOT, 0, DF_NO_IC, 0, scoeffs, DF_NO_HINT);
float* scoeffs = Aurora::malloc(ny * (nx-1) * sorder);
status = dfsEditPPSpline1D(task, sorder,DF_PP_NATURAL , DF_BC_NOT_A_KNOT, 0, DF_NO_IC, 0, scoeffs, DF_NO_HINT);
if (status != DF_STATUS_OK)
{
return Matrix();
}
status = dfdConstruct1D( task, DF_PP_SPLINE, DF_METHOD_STD );
status = dfsConstruct1D( task, DF_PP_SPLINE, DF_METHOD_STD );
if (status != DF_STATUS_OK)
{
return Matrix();
}
int dorder = 1;
status = dfdInterpolate1D(task, DF_INTERP, DF_METHOD_PP, nx1, aX1.getData(), DF_NO_HINT, 1, &dorder,
status = dfsInterpolate1D(task, DF_INTERP, DF_METHOD_PP, nx1, aX1.getData(), DF_NO_HINT, 1, &dorder,
DF_NO_APRIORI_INFO, resultData.get(), DF_MATRIX_STORAGE_ROWS, nullptr);
status = dfDeleteTask(&task);
@@ -412,20 +412,20 @@ Matrix Aurora::repmat(const Matrix& aMatrix,int aRowTimes, int aColumnTimes)
}
int complexStep = aMatrix.getValueType();
int originalDataSize = aMatrix.getDataSize() * complexStep;
double* resultData = Aurora::malloc(originalDataSize * aRowTimes * aColumnTimes);
float* resultData = Aurora::malloc(originalDataSize * aRowTimes * aColumnTimes);
int row = aMatrix.getDimSize(0);
int column = aMatrix.getDimSize(1);
double* originalData = aMatrix.getData();
double* resultDataTemp = resultData;
float* originalData = aMatrix.getData();
float* resultDataTemp = resultData;
size_t step = row*complexStep;
#pragma omp parallel for
for(int i=0; i<column; ++i)
{
double* origninalStart = originalData + i * step;
float* origninalStart = originalData + i * step;
for(int j=0; j<aRowTimes; ++j)
{
double* copyStart = resultData + step * (i*aRowTimes + j);
cblas_dcopy(step, origninalStart, 1, copyStart, 1);
float* copyStart = resultData + step * (i*aRowTimes + j);
cblas_scopy(step, origninalStart, 1, copyStart, 1);
//resultDataTemp += row*complexStep;
}
//originalData += step;
@@ -436,7 +436,7 @@ Matrix Aurora::repmat(const Matrix& aMatrix,int aRowTimes, int aColumnTimes)
#pragma omp parallel for
for(int i=1; i<aColumnTimes; ++i)
{
cblas_dcopy(step, resultData, 1, resultData + i*step, 1);
cblas_scopy(step, resultData, 1, resultData + i*step, 1);
}
std::vector<int> resultInfo;
@@ -447,7 +447,7 @@ Matrix Aurora::repmat(const Matrix& aMatrix,int aRowTimes, int aColumnTimes)
resultInfo.push_back(column);
}
return Matrix(std::shared_ptr<double>(resultData, Aurora::free),resultInfo, aMatrix.getValueType());
return Matrix(std::shared_ptr<float>(resultData, Aurora::free),resultInfo, aMatrix.getValueType());
}
Matrix Aurora::repmat(const Matrix& aMatrix,int aRowTimes, int aColumnTimes, int aSliceTimes)
@@ -460,11 +460,11 @@ Matrix Aurora::repmat(const Matrix& aMatrix,int aRowTimes, int aColumnTimes, int
int complexStep = aMatrix.getValueType();
Matrix resultTemp = Aurora::repmat(aMatrix, aRowTimes, aColumnTimes);
int resultTempDataSize = resultTemp.getDataSize() * complexStep;
double* resultData = Aurora::malloc(resultTempDataSize * aSliceTimes);
float* resultData = Aurora::malloc(resultTempDataSize * aSliceTimes);
std::copy(resultTemp.getData(), resultTemp.getData() + resultTempDataSize, resultData);
for(int i=1; i<aSliceTimes; ++i)
{
cblas_dcopy(resultTempDataSize, resultData, 1, resultData + i*resultTempDataSize, 1);
cblas_scopy(resultTempDataSize, resultData, 1, resultData + i*resultTempDataSize, 1);
}
std::vector<int> resultInfo;
int row = resultTemp.getDimSize(0);
@@ -479,7 +479,7 @@ Matrix Aurora::repmat(const Matrix& aMatrix,int aRowTimes, int aColumnTimes, int
resultInfo.push_back(aSliceTimes);
}
return Matrix(std::shared_ptr<double>(resultData, Aurora::free), resultInfo, aMatrix.getValueType());
return Matrix(std::shared_ptr<float>(resultData, Aurora::free), resultInfo, aMatrix.getValueType());
}
Matrix Aurora::repmat3d(const Matrix& aMatrix,int aRowTimes, int aColumnTimes, int aSliceTimes)
@@ -488,27 +488,27 @@ Matrix Aurora::repmat3d(const Matrix& aMatrix,int aRowTimes, int aColumnTimes, i
{
return Matrix();
}
double* start = aMatrix.getData();
float* start = aMatrix.getData();
int rows = aMatrix.getDimSize(0);
int columns = aMatrix.getDimSize(1);
int slices = aMatrix.getDimSize(2);
double* extended2DimsData = Aurora::malloc(rows * columns * aRowTimes * aColumnTimes * slices);
float* extended2DimsData = Aurora::malloc(rows * columns * aRowTimes * aColumnTimes * slices);
Matrix extended2DimsMatrix = Matrix::New(extended2DimsData, aRowTimes*rows, aColumnTimes*columns, slices);
for(int i=0; i<aMatrix.getDimSize(2); ++i)
{
Matrix dim2Matrix = Matrix::copyFromRawData(start, rows, columns);
Matrix extendedTemp = repmat(dim2Matrix, aRowTimes, aColumnTimes);
cblas_dcopy(extendedTemp.getDataSize(), extendedTemp.getData(), 1, extended2DimsData, 1);
cblas_scopy(extendedTemp.getDataSize(), extendedTemp.getData(), 1, extended2DimsData, 1);
extended2DimsData += extendedTemp.getDataSize();
start += columns * rows;
}
double* extended3DimsData = Aurora::malloc(rows * columns * aRowTimes * aColumnTimes * aSliceTimes * slices);
float* extended3DimsData = Aurora::malloc(rows * columns * aRowTimes * aColumnTimes * aSliceTimes * slices);
Matrix result = Matrix::New(extended3DimsData, aRowTimes*rows, aColumnTimes*columns, slices * aSliceTimes);
for(int i=0;i<aSliceTimes;++i)
{
cblas_dcopy(extended2DimsMatrix.getDataSize(), extended2DimsMatrix.getData(), 1, extended3DimsData, 1);
cblas_scopy(extended2DimsMatrix.getDataSize(), extended2DimsMatrix.getData(), 1, extended3DimsData, 1);
extended3DimsData+=extended2DimsMatrix.getDataSize();
}
return result;
@@ -517,16 +517,16 @@ Matrix Aurora::repmat3d(const Matrix& aMatrix,int aRowTimes, int aColumnTimes, i
Matrix Aurora::polyval(const Matrix &aP, const Matrix &aX) {
auto result = malloc(aX.getDataSize());
auto powArg = new double[aP.getDataSize()];
auto powArg = new float[aP.getDataSize()];
for (int j = aP.getDataSize(), i = 0; j > 0; --j, ++i) {
powArg[i] = (double) (j - 1);
powArg[i] = (float) (j - 1);
}
auto temp = new double[aP.getDataSize()];
auto temp = new float[aP.getDataSize()];
for (int i = 0; i < aX.getDataSize(); ++i) {
vdPowI(aP.getDataSize(), aX.getData() + i, 0, powArg, 1, temp, 1);
vdMul(aP.getDataSize(), aP.getData(), temp, temp);
Eigen::Map<Eigen::VectorXd> vd(temp,aP.getDataSize());
result[i] = vd.array().sum();
vsPowI(aP.getDataSize(), aX.getData() + i, 0, powArg, 1, temp, 1);
vsMul(aP.getDataSize(), aP.getData(), temp, temp);
Eigen::Map<Eigen::VectorXf> vs(temp,aP.getDataSize());
result[i] = vs.array().sum();
}
delete[] powArg;
delete[] temp;
@@ -537,13 +537,13 @@ Matrix Aurora::polyval(const Matrix &aP, const Matrix &aX) {
Matrix Aurora::log(const Matrix& aMatrix, int aBaseNum)
{
size_t size = aMatrix.getDataSize();
double* data = Aurora::malloc(size);
vdLn(size, aMatrix.getData(), data);
float* data = Aurora::malloc(size);
vsLn(size, aMatrix.getData(), data);
if(aBaseNum != -1)
{
double baseNum = aBaseNum;
double temp;
vdLn(1, &baseNum, &temp);
float baseNum = aBaseNum;
float temp;
vsLn(1, &baseNum, &temp);
for (size_t i = 0; i < size; i++)
{
data[i] /= temp;
@@ -555,21 +555,21 @@ Matrix Aurora::log(const Matrix& aMatrix, int aBaseNum)
Matrix Aurora::exp(const Matrix& aMatrix)
{
size_t size = aMatrix.getDataSize();
double* data;
float* data;
if (aMatrix.isComplex())
{
data = Aurora::malloc(size, true);
vzExp(size, (MKL_Complex16*)aMatrix.getData(), (MKL_Complex16*)data);
vcExp(size, (MKL_Complex8*)aMatrix.getData(), (MKL_Complex8*)data);
}
else
{
data = Aurora::malloc(size);
vdExp(size, aMatrix.getData(), data);
vsExp(size, aMatrix.getData(), data);
}
return Matrix::New(data, aMatrix);
}
Matrix Aurora::mod(const Matrix& aMatrix, double aValue)
Matrix Aurora::mod(const Matrix& aMatrix, float aValue)
{
if(aMatrix.isComplex() || aMatrix.isNull())
{
@@ -577,8 +577,8 @@ Matrix Aurora::mod(const Matrix& aMatrix, double aValue)
}
size_t size = aMatrix.getDataSize();
double* matrixData = aMatrix.getData();
double* resultData = Aurora::malloc(size);
float* matrixData = aMatrix.getData();
float* resultData = Aurora::malloc(size);
for(size_t i=0; i<size; ++i)
{
resultData[i] = fmod(matrixData[i], aValue);
@@ -595,9 +595,9 @@ Matrix Aurora::acos(const Matrix& aMatrix)
}
size_t size = aMatrix.getDataSize();
double* matrixData = aMatrix.getData();
double* resultData = Aurora::malloc(size);
vdAcos(size, matrixData, resultData);
float* matrixData = aMatrix.getData();
float* resultData = Aurora::malloc(size);
vsAcos(size, matrixData, resultData);
return Matrix::New(resultData, aMatrix);
}
@@ -609,9 +609,9 @@ Matrix Aurora::acosd(const Matrix& aMatrix)
}
size_t size = aMatrix.getDataSize();
double* matrixData = aMatrix.getData();
double* resultData = Aurora::malloc(size);
vdAcos(size, matrixData, resultData);
float* matrixData = aMatrix.getData();
float* resultData = Aurora::malloc(size);
vsAcos(size, matrixData, resultData);
for(size_t i=0; i<size; ++i)
{
resultData[i] = resultData[i] * 180 / PI;
@@ -626,12 +626,12 @@ Matrix Aurora::conj(const Matrix& aMatrix)
return Matrix::copyFromRawData(aMatrix.getData(),aMatrix.getDimSize(0),aMatrix.getDimSize(1),aMatrix.getDimSize(2));
}
size_t size = aMatrix.getDataSize();
double* data = malloc(size,true);
vzConj(size,(MKL_Complex16*)aMatrix.getData(), (MKL_Complex16*)data);
float* data = malloc(size,true);
vcConj(size,(MKL_Complex8*)aMatrix.getData(), (MKL_Complex8*)data);
return Matrix::New(data, aMatrix);
}
double Aurora::norm(const Matrix& aMatrix, NormMethod aNormMethod)
float Aurora::norm(const Matrix& aMatrix, NormMethod aNormMethod)
{
if(aMatrix.isNull())
{
@@ -647,10 +647,10 @@ double Aurora::norm(const Matrix& aMatrix, NormMethod aNormMethod)
int row = aMatrix.getDimSize(0);
if (aNormMethod == NormMethod::Norm1)
{
double value = 0;
float value = 0;
for(int i=0; i<column; ++i)
{
double temp = Aurora::sum(abs(aMatrix($,i,$).toMatrix())).getData()[0];
float temp = Aurora::sum(abs(aMatrix($,i,$).toMatrix())).getData()[0];
if(temp > value)
{
value = temp;
@@ -660,7 +660,7 @@ double Aurora::norm(const Matrix& aMatrix, NormMethod aNormMethod)
}
else if(aNormMethod == NormMethod::NormF)
{
return cblas_dnrm2(size, aMatrix.getData(), 1);
return cblas_snrm2(size, aMatrix.getData(), 1);
}
else if(aNormMethod == NormMethod::Norm2)
{
@@ -669,20 +669,20 @@ double Aurora::norm(const Matrix& aMatrix, NormMethod aNormMethod)
{
if(aMatrix.isComplex())
{
Eigen::Map<Eigen::MatrixXcd> eMatrix((MKL_Complex16*)aMatrix.getData(), row, column);
Eigen::JacobiSVD<Eigen::MatrixXcd> svd(eMatrix, Eigen::ComputeThinU | Eigen::ComputeThinV);
return svd.singularValues()(0);
Eigen::Map<Eigen::MatrixXcf> eMatrix((MKL_Complex8*)aMatrix.getData(), row, column);
Eigen::JacobiSVD<Eigen::MatrixXcf> svs(eMatrix, Eigen::ComputeThinU | Eigen::ComputeThinV);
return svs.singularValues()(0);
}
else
{
Eigen::Map<Eigen::MatrixXd> eMatrix(aMatrix.getData(), row, column);
Eigen::JacobiSVD<Eigen::MatrixXd> svd(eMatrix, Eigen::ComputeThinU | Eigen::ComputeThinV);
return svd.singularValues()(0);
Eigen::Map<Eigen::MatrixXf> eMatrix(aMatrix.getData(), row, column);
Eigen::JacobiSVD<Eigen::MatrixXf> svs(eMatrix, Eigen::ComputeThinU | Eigen::ComputeThinV);
return svs.singularValues()(0);
}
}
else
{
return cblas_dnrm2(size, aMatrix.getData(), 1);
return cblas_snrm2(size, aMatrix.getData(), 1);
}
}
@@ -699,17 +699,17 @@ Matrix Aurora::transpose(const Matrix& aMatrix)
size_t size = aMatrix.getDataSize();
int row = aMatrix.getDimSize(0);
int col = aMatrix.getDimSize(1);
double* resultData;
double* data = aMatrix.getData();
float* resultData;
float* data = aMatrix.getData();
if(aMatrix.isComplex())
{
resultData = Aurora::malloc(size, true);
mkl_zomatcopy('C', 'T',row ,col, 1.0, (MKL_Complex16*)data, row, (MKL_Complex16*)resultData, col);
mkl_comatcopy('C', 'T',row ,col, 1.0, (MKL_Complex8*)data, row, (MKL_Complex8*)resultData, col);
}
else
{
resultData = Aurora::malloc(size);
mkl_domatcopy('C', 'T',row ,col, 1.0, data, row, resultData, col);
mkl_somatcopy('C', 'T',row ,col, 1.0, data, row, resultData, col);
}
return Matrix::New(resultData,col,row,1,aMatrix.getValueType());
@@ -728,12 +728,12 @@ Matrix Aurora::horzcat(const Matrix& aMatrix1, const Matrix& aMatrix2)
int row = aMatrix1.getDimSize(0);
size_t size1= row*column1;
size_t size2= row*column2;
double* resultData = Aurora::malloc(aMatrix1.getDataSize() + aMatrix2.getDataSize(),aMatrix1.getValueType());
float* resultData = Aurora::malloc(aMatrix1.getDataSize() + aMatrix2.getDataSize(),aMatrix1.getValueType());
size_t sliceStride = row*(column1+column2);
for (size_t i = 0; i < slice; i++)
{
cblas_dcopy(size1, aMatrix1.getData()+i*size1 , 1, resultData + i*sliceStride, 1);
cblas_dcopy(size2, aMatrix2.getData()+i*size2, 1, resultData + i*sliceStride + size1, 1);
cblas_scopy(size1, aMatrix1.getData()+i*size1 , 1, resultData + i*sliceStride, 1);
cblas_scopy(size2, aMatrix2.getData()+i*size2, 1, resultData + i*sliceStride + size1, 1);
}
return Matrix::New(resultData, row, column1+column2, slice, aMatrix1.getValueType());
}
@@ -751,9 +751,9 @@ Matrix Aurora::vertcat(const Matrix& aMatrix1, const Matrix& aMatrix2){
int column = aMatrix1.getDimSize(1);
size_t size1= aMatrix1.getDataSize();
size_t size2= aMatrix2.getDataSize();
double* resultData = Aurora::malloc(size1 + size2,aMatrix1.getValueType());
cblas_dcopy_batch_strided(row1, aMatrix1.getData(), 1,row1, resultData, 1, row1+row2, column*slice);
cblas_dcopy_batch_strided(row2, aMatrix2.getData(), 1,row2, resultData + row1, 1, row1+row2, column*slice);
float* resultData = Aurora::malloc(size1 + size2,aMatrix1.getValueType());
cblas_scopy_batch_strided(row1, aMatrix1.getData(), 1,row1, resultData, 1, row1+row2, column*slice);
cblas_scopy_batch_strided(row2, aMatrix2.getData(), 1,row2, resultData + row1, 1, row1+row2, column*slice);
return Matrix::New(resultData, row1+row2, column, slice, aMatrix1.getValueType());
}
@@ -766,7 +766,7 @@ Matrix Aurora::vecnorm(const Matrix& aMatrix, NormMethod aNormMethod, int aDim)
return Matrix();
}
int column = aMatrix.getDimSize(1);
double* resultData = Aurora::malloc(column);
float* resultData = Aurora::malloc(column);
for(int i=0; i<column; ++i)
{
resultData[i] = norm(aMatrix($,i,$).toMatrix(), aNormMethod);
@@ -775,10 +775,10 @@ Matrix Aurora::vecnorm(const Matrix& aMatrix, NormMethod aNormMethod, int aDim)
return Matrix::New(resultData,column);
}
Matrix Aurora::linspace(double aStart, double aEnd, int aNum)
Matrix Aurora::linspace(float aStart, float aEnd, int aNum)
{
double step = (aEnd - aStart) / (aNum - 1);
double* resultData = Aurora::malloc(aNum);
float step = (aEnd - aStart) / (aNum - 1);
float* resultData = Aurora::malloc(aNum);
for (int i = 0; i < aNum; i++)
{
resultData[i] = aStart + step * i;
@@ -796,10 +796,10 @@ Matrix Aurora::auroraUnion(const Matrix& aMatrix1, const Matrix& aMatrix2)
size_t size1= aMatrix1.getDataSize();
size_t size2= aMatrix2.getDataSize();
double* resultData = Aurora::malloc(size1 + size2);
cblas_dcopy(size1, aMatrix1.getData(), 1, resultData, 1);
cblas_dcopy(size2, aMatrix2.getData(), 1, resultData + size1, 1);
std::vector<double> vector(resultData, resultData + size1 + size2);
float* resultData = Aurora::malloc(size1 + size2);
cblas_scopy(size1, aMatrix1.getData(), 1, resultData, 1);
cblas_scopy(size2, aMatrix2.getData(), 1, resultData + size1, 1);
std::vector<float> vector(resultData, resultData + size1 + size2);
Aurora::free(resultData);
std::sort(vector.begin(), vector.end());
auto last = std::unique(vector.begin(), vector.end());
@@ -817,12 +817,12 @@ Matrix Aurora::intersect(const Matrix& aMatrix1, const Matrix& aMatrix2)
size_t size1= aMatrix1.getDataSize();
size_t size2= aMatrix2.getDataSize();
std::vector<double> vector1(aMatrix1.getData(), aMatrix1.getData() + size1);
std::vector<double> vector2(aMatrix2.getData(), aMatrix2.getData() + size2);
std::vector<float> vector1(aMatrix1.getData(), aMatrix1.getData() + size1);
std::vector<float> vector2(aMatrix2.getData(), aMatrix2.getData() + size2);
std::sort(vector1.begin(), vector1.end());
std::sort(vector2.begin(), vector2.end());
std::vector<double> intersection;
std::vector<float> intersection;
std::set_intersection(vector1.begin(), vector1.end(),
vector2.begin(), vector2.end(),
std::back_inserter(intersection));
@@ -840,7 +840,7 @@ Matrix Aurora::intersect(const Matrix& aMatrix1, const Matrix& aMatrix2, Matrix&
Matrix result = intersect(aMatrix1,aMatrix2);
size_t size = result.getDataSize();
double* iaResult = Aurora::malloc(size);
float* iaResult = Aurora::malloc(size);
for(size_t i=0; i<size; ++i)
{
for(size_t j=0; j<aMatrix1.getDataSize(); ++j)
@@ -866,10 +866,10 @@ Matrix Aurora::xcorr(const Matrix& aMatrix1, const Matrix& aMatrix2)
}
size_t matrixSize = aMatrix1.getDataSize();
size_t resultSize = 2 * matrixSize -1;
double* resultData = Aurora::malloc(resultSize);
float* resultData = Aurora::malloc(resultSize);
for(int i=0;i<matrixSize;++i)
{
double data = 0;
float data = 0;
for(int j=0;j<i+1;++j)
{
data+= aMatrix1[j] * aMatrix2[matrixSize-i-1+j];
@@ -879,7 +879,7 @@ Matrix Aurora::xcorr(const Matrix& aMatrix1, const Matrix& aMatrix2)
for(int i=0;i<matrixSize-1;++i)
{
double result = 0;
float result = 0;
for(int j=0;j<i+1;++j)
{
result+= aMatrix1[matrixSize-i-1+j]*aMatrix2[j];
@@ -900,29 +900,29 @@ Matrix Aurora::deleteColumn(const Matrix& aMatrix, int aColumnIndex)
return aMatrix;
}
double* resultData = Aurora::malloc(rows* (columns-1));
float* resultData = Aurora::malloc(rows* (columns-1));
if(aColumnIndex == 0)
{
cblas_dcopy(rows* (columns-1), aMatrix.getData() + rows, 1, resultData, 1);
cblas_scopy(rows* (columns-1), aMatrix.getData() + rows, 1, resultData, 1);
}
else if(aColumnIndex == (columns - 1))
{
cblas_dcopy(rows* (columns-1), aMatrix.getData(), 1, resultData, 1);
cblas_scopy(rows* (columns-1), aMatrix.getData(), 1, resultData, 1);
}
else
{
cblas_dcopy(rows * aColumnIndex, aMatrix.getData(), 1, resultData, 1);
cblas_dcopy(rows * (columns - aColumnIndex - 1), aMatrix.getData() + rows * (aColumnIndex + 1), 1, resultData + rows * aColumnIndex, 1);
cblas_scopy(rows * aColumnIndex, aMatrix.getData(), 1, resultData, 1);
cblas_scopy(rows * (columns - aColumnIndex - 1), aMatrix.getData() + rows * (aColumnIndex + 1), 1, resultData + rows * aColumnIndex, 1);
}
return Matrix::New(resultData, rows, columns-1);
}
Matrix Aurora::createVectorMatrix(double aStartValue, double aStepValue, double aEndValue)
Matrix Aurora::createVectorMatrix(float aStartValue, float aStepValue, float aEndValue)
{
std::vector<double> matrixData;
double tempValue = aStartValue;
std::vector<float> matrixData;
float tempValue = aStartValue;
matrixData.push_back(tempValue);
long long compare1 = std::round(aEndValue * 10e13);
long long compare2 = std::round(tempValue * 10e13);
@@ -945,28 +945,28 @@ Matrix Aurora::reshape(const Matrix& aMatrix, int aRows, int aColumns, int aSlic
}
return Matrix::copyFromRawData(aMatrix.getData(),aRows,aColumns,aSlices);
}
void Aurora::nantoval(Matrix& aMatrix, double val2) {
Eigen::Map<Eigen::VectorXd> srcV(aMatrix.getData(),aMatrix.getDataSize());
void Aurora::nantoval(Matrix& aMatrix, float val2) {
Eigen::Map<Eigen::VectorXf> srcV(aMatrix.getData(),aMatrix.getDataSize());
srcV = srcV.array().isNaN().select(val2,srcV);
}
Matrix Aurora::isnan(const Matrix& aMatrix){
Eigen::Map<Eigen::VectorXd> srcV(aMatrix.getData(),aMatrix.getDataSize());
Eigen::Map<Eigen::VectorXf> srcV(aMatrix.getData(),aMatrix.getDataSize());
auto result = zeros(aMatrix.getDimSize(0),aMatrix.getDimSize(1),aMatrix.getDimSize(2));
Eigen::Map<Eigen::VectorXd> resultV(result.getData(),result.getDataSize());
Eigen::Map<Eigen::VectorXf> resultV(result.getData(),result.getDataSize());
resultV = srcV.array().isNaN().select(1.0,resultV);
return result;
}
Matrix Aurora::isfinite(const Matrix& aMatrix){
Eigen::Map<Eigen::VectorXd> srcV(aMatrix.getData(),aMatrix.getDataSize());
Eigen::Map<Eigen::VectorXf> srcV(aMatrix.getData(),aMatrix.getDataSize());
auto result = zeros(aMatrix.getDimSize(0),aMatrix.getDimSize(1),aMatrix.getDimSize(2));
Eigen::Map<Eigen::VectorXd> resultV(result.getData(),result.getDataSize());
Eigen::Map<Eigen::VectorXf> resultV(result.getData(),result.getDataSize());
resultV = srcV.array().isFinite().select(1.0,resultV);
return result;
}
void Aurora::padding(Matrix &aMatrix, int aIndex, double aValue)
void Aurora::padding(Matrix &aMatrix, int aIndex, float aValue)
{
if(aMatrix.isNull() || !aMatrix.isVector())
{
@@ -978,16 +978,16 @@ void Aurora::padding(Matrix &aMatrix, int aIndex, double aValue)
return;
}
int size = (aIndex+1);
double* newData = malloc(size,aMatrix.isComplex());
cblas_dcopy(aMatrix.getDataSize()*aMatrix.getValueType(),
float* newData = malloc(size,aMatrix.isComplex());
cblas_scopy(aMatrix.getDataSize()*aMatrix.getValueType(),
aMatrix.getData(),1,newData,1);
cblas_dcopy((size-aMatrix.getDataSize())*aMatrix.getValueType(),
cblas_scopy((size-aMatrix.getDataSize())*aMatrix.getValueType(),
&aValue,0,newData+aMatrix.getDataSize()*aMatrix.getValueType(),1);
aMatrix = Matrix::New(newData,size,1,1,aMatrix.getValueType());
}
void Aurora::compareSet(Matrix& aMatrix,double compareValue, double newValue,CompareOp op){
Eigen::Map<Eigen::VectorXd> v(aMatrix.getData(),aMatrix.getDataSize());
void Aurora::compareSet(Matrix& aMatrix,float compareValue, float newValue,CompareOp op){
Eigen::Map<Eigen::VectorXf> v(aMatrix.getData(),aMatrix.getDataSize());
switch (op) {
case EQ:
v = (v.array() == compareValue).select(newValue, v);
@@ -1010,9 +1010,9 @@ void Aurora::compareSet(Matrix& aMatrix,double compareValue, double newValue,Com
}
}
void Aurora::compareSet(Matrix& aMatrix,Matrix& aCompareMatrix,double compareValue, double newValue,CompareOp op){
Eigen::Map<Eigen::VectorXd> v(aMatrix.getData(),aMatrix.getDataSize());
Eigen::Map<Eigen::VectorXd> c(aCompareMatrix.getData(),aCompareMatrix.getDataSize());
void Aurora::compareSet(Matrix& aMatrix,Matrix& aCompareMatrix,float compareValue, float newValue,CompareOp op){
Eigen::Map<Eigen::VectorXf> v(aMatrix.getData(),aMatrix.getDataSize());
Eigen::Map<Eigen::VectorXf> c(aCompareMatrix.getData(),aCompareMatrix.getDataSize());
switch (op) {
case EQ:
v = (c.array() == compareValue).select(newValue, v);
@@ -1035,9 +1035,9 @@ void Aurora::compareSet(Matrix& aMatrix,Matrix& aCompareMatrix,double compareVal
}
}
void Aurora::compareSet(Matrix& aValueAndCompareMatrix,Matrix& aOtherCompareMatrix, double newValue,CompareOp op){
Eigen::Map<Eigen::VectorXd> v(aValueAndCompareMatrix.getData(),aValueAndCompareMatrix.getDataSize());
Eigen::Map<Eigen::VectorXd> c(aOtherCompareMatrix.getData(),aOtherCompareMatrix.getDataSize());
void Aurora::compareSet(Matrix& aValueAndCompareMatrix,Matrix& aOtherCompareMatrix, float newValue,CompareOp op){
Eigen::Map<Eigen::VectorXf> v(aValueAndCompareMatrix.getData(),aValueAndCompareMatrix.getDataSize());
Eigen::Map<Eigen::VectorXf> c(aOtherCompareMatrix.getData(),aOtherCompareMatrix.getDataSize());
switch (op) {
case EQ:
v = (v.array() == c.array()).select(newValue, v);
@@ -1059,9 +1059,9 @@ void Aurora::compareSet(Matrix& aValueAndCompareMatrix,Matrix& aOtherCompareMatr
break;
}
}
void Aurora::compareSet(Matrix& aCompareMatrix,double compareValue, Matrix& aNewValueMatrix,CompareOp op){
Eigen::Map<Eigen::VectorXd> v(aCompareMatrix.getData(),aCompareMatrix.getDataSize());
Eigen::Map<Eigen::VectorXd> nv(aNewValueMatrix.getData(),aNewValueMatrix.getDataSize());
void Aurora::compareSet(Matrix& aCompareMatrix,float compareValue, Matrix& aNewValueMatrix,CompareOp op){
Eigen::Map<Eigen::VectorXf> v(aCompareMatrix.getData(),aCompareMatrix.getDataSize());
Eigen::Map<Eigen::VectorXf> nv(aNewValueMatrix.getData(),aNewValueMatrix.getDataSize());
switch (op) {
case EQ:
v = (v.array() == compareValue).select(nv, v);
@@ -1115,13 +1115,13 @@ Matrix Aurora::uniqueByRows(const Matrix& aMatrix, Matrix& aIndexResult)
return Matrix();
}
Matrix transposeMatrix = transpose(aMatrix);
double* transposeMatrixData = transposeMatrix.getData();
float* transposeMatrixData = transposeMatrix.getData();
int rows = transposeMatrix.getDimSize(0);
int columns = transposeMatrix.getDimSize(1);
std::vector<Matrix> uniqueResult;
for(int i=1; i<=columns; ++i)
{
Matrix rowData = Matrix::fromRawData(new double[rows], rows);
Matrix rowData = Matrix::fromRawData(new float[rows], rows);
std::copy(transposeMatrixData, transposeMatrixData + rows, rowData.getData());
uniqueResult.push_back(rowData);
transposeMatrixData += rows;
@@ -1132,7 +1132,7 @@ Matrix Aurora::uniqueByRows(const Matrix& aMatrix, Matrix& aIndexResult)
auto uniqueIndex = std::unique(uniqueResult.begin(), uniqueResult.end(), isEqual);
uniqueResult.erase(uniqueIndex, uniqueResult.end());
std::vector<double> indexResultData;
std::vector<float> indexResultData;
for(int i=0; i<matrixsCopy.size();++i)
{
auto index = lower_bound(uniqueResult.begin(), uniqueResult.end(), matrixsCopy[i], compare);
@@ -1142,7 +1142,7 @@ Matrix Aurora::uniqueByRows(const Matrix& aMatrix, Matrix& aIndexResult)
aIndexResult = Matrix::copyFromRawData(indexResultData.data(), indexResultData.size());
size_t resultSize = rows * uniqueResult.size();
double* resultData = new double[resultSize];
float* resultData = new float[resultSize];
Matrix result = Matrix::fromRawData(resultData, rows, uniqueResult.size()) ;
for(size_t i=0; i<uniqueResult.size(); ++i)
{