/* ******************************************************************************
*
*
* This program and the accompanying materials are made available under the
* terms of the Apache License, Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0.
*
* See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
* SPDX-License-Identifier: Apache-2.0
******************************************************************************/
//
// Created by agibsonccc on 1/6/17.
//
#include <helpers/data_gen.h>
#include "testinclude.h"
#include <helpers/TAD.h>
#include <helpers/ShapeBuilders.h>
class OnesTest : public testing::Test {
public:
Nd4jLong shapeBuffer[12] = {4,4,3,1,1,3,1,1,1,0,1,99};
int dimension[3] = {0,2,3};
Nd4jLong tadAssertionShape[10] = {3,1,1,4,1,1,3,0,3,99};
int dimensionLength = 3;
};
class LabelTest : public testing::Test {
public:
float labels[450] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0};
Nd4jLong shapeInfo[8] = {2,150,3,1,150,16384,1,102};
int dimension[1] = {1};
int dimensionLength = 1;
Nd4jLong tadShapeInfoAssert[8] = {2,1,3,1,150,16384,150,102};
};
class ThreeDTest : public testing::Test {
public:
Nd4jLong shape[3] = {3,4,5};
Nd4jLong *shapeBuffer;
ThreeDTest() {
shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, shape);
}
~ThreeDTest() {
delete[] shapeBuffer;
}
};
class VectorTest : public testing::Test {
};
class NumTadTests : public testing::Test {
public:
Nd4jLong shape[3] = {3,4,5};
int dimension = 0;
};
class ShapeTest : public testing::Test {
public:
Nd4jLong vectorShape[2] = {1,2};
};
class MatrixTest : public testing::Test {
public:
int rows = 3;
int cols = 4;
int rank = 2;
int dims[2] = {0,1};
Nd4jLong expectedShapes[2][2] = {
{1,3},
{1,4}
};
Nd4jLong expectedStrides[2][2] = {
{1,4},
{1,1}
};
};
class TADStall : public testing::Test {
public:
Nd4jLong shape[4] = {3,3,4,5};
int dimensions[3] = {1,2,3};
};
class TensorOneDimTest : public testing::Test {
public:
int rows = 3;
int cols = 4;
int dim2 = 5;
int rank = 3;
int dims[3] = {0,1,2};
Nd4jLong expectedShapes[3][2] = {
{1,3},
{1,4},
{1,5}
};
Nd4jLong expectedStrides[3][2] = {
{1,20},
{1,5},
{1,1}
};
};
class TensorTwoDimTest : public testing::Test {
public:
//From a 3d array:
int rows = 3;
int cols = 4;
int dim2 = 5;
int dimensionLength = 2;
int dims[3][2] = {
{0,1},{0,2},{1,2}
};
Nd4jLong shape[3] {rows,cols,dim2};
//Along dimension 0,1: expect matrix with shape [rows,cols]
//Along dimension 0,2: expect matrix with shape [rows,dim2]
//Along dimension 1,2: expect matrix with shape [cols,dim2]
Nd4jLong expectedShapes[3][2] = {
{rows,cols},
{rows,dim2},
{cols,dim2}
};
Nd4jLong expectedStrides[3][2] = {
{20,5},
{20,1},
{5,1}
};
};
class TensorTwoFromFourDDimTest : public testing::Test {
public:
//From a 3d array:
int rows = 3;
int cols = 4;
int dim2 = 5;
int dim3 = 6;
Nd4jLong shape[4] = {rows,cols,dim2,dim3};
int dimensionLength = 2;
//Along dimension 0,1: expect matrix with shape [rows,cols]
//Along dimension 0,2: expect matrix with shape [rows,dim2]
//Along dimension 0,3: expect matrix with shape [rows,dim3]
//Along dimension 1,2: expect matrix with shape [cols,dim2]
//Along dimension 1,3: expect matrix with shape [cols,dim3]
//Along dimension 2,3: expect matrix with shape [dim2,dim3]
int dims[6][2] = {
{0,1},
{0,2},
{0,3},
{1,2},
{1,3},
{2,3}
};
Nd4jLong expectedShapes[6][2] = {
{rows,cols},
{rows,dim2},
{rows,dim3},
{cols,dim2},
{cols,dim3}
,{dim2,dim3}
};
Nd4jLong expectedStrides[6][2] = {
{120,30},
{120,6},
{120,1},
{30,6},
{30,1},
{6,1}
};
};
class OrderTest : public testing::Test {
public:
Nd4jLong expected[8] = {2,3,4,1,3,0,0,102};
Nd4jLong test[8] = {2,3,4,1,3,0,0,102};
};
class LeadingOnes : public testing::Test {
public:
Nd4jLong shapeBufferF[16] = {4,1,1,4,4,1,1,1,4,16384,1,102}; // shapes with data type DOUBLE
Nd4jLong shapeBufferC[16] = {4,1,1,4,4,16,16,4,1,16384,1,99};
int dimensionLength = 2;
int dimension[2] = {2,3};
Nd4jLong tadAssertionC[10] = {3,4,4,1,4,1,16,16384,1,99};
Nd4jLong tadCAssertionF[10] = {3,4,4,1,1,4,1,16384,1,102};
};
TEST_F(LeadingOnes,OnesTest) {
shape::TAD *cTad = new shape::TAD;
cTad->init(shapeBufferC,dimension,dimensionLength);
cTad->createTadOnlyShapeInfo();
cTad->createOffsets();
shape::TAD *fTad = new shape::TAD;
fTad->init(shapeBufferF,dimension,dimensionLength);
fTad->createTadOnlyShapeInfo();
fTad->createOffsets();
// shape::printShapeInfoLinear(cTad->tadOnlyShapeInfo);
// shape::printShapeInfoLinear(fTad->tadOnlyShapeInfo);
ASSERT_TRUE(arrsEquals(10, tadCAssertionF, fTad->tadOnlyShapeInfo));
ASSERT_TRUE(arrsEquals(10, tadAssertionC, cTad->tadOnlyShapeInfo));
delete cTad;
delete fTad;
}
class NormalThreeFourFive : public testing::Test {
public:
Nd4jLong assertionBuffer[8] = {2, 3, 4, 20, 5, 16384, 5, 99};
Nd4jLong inputShapeBuffer[10] = {3,3,4,5,20,5,1,16384,1,99};
int dimensionLength = 2;
int dimension[2] = {0,1};
};
TEST_F(NormalThreeFourFive,DimensionTest) {
shape::TAD *tad = new shape::TAD;
tad->init(inputShapeBuffer,dimension,dimensionLength);
tad->createTadOnlyShapeInfo();
tad->createOffsets();
ASSERT_TRUE(arrsEquals(8,assertionBuffer,tad->tadOnlyShapeInfo));
delete tad;
}
class DimensionWarning : public testing::Test {
public:
int dimensionLength = 2;
int dimensions[2] = {0,1};
Nd4jLong shape[3] = {1,5,1};
Nd4jLong *shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, shape);
~DimensionWarning() {
delete[] shapeBuffer;
}
};
TEST_F(DimensionWarning,ShapeWarning) {
shape::TAD *tad = new shape::TAD;
tad->init(shapeBuffer,dimensions,dimensionLength);
tad->createTadOnlyShapeInfo();
tad->createOffsets();
delete tad;
}
class TadRank : public testing::Test {
Nd4jLong shapeBuffer[12] = {4,2,1,3,3,9,9,3,1,0,1,99};
int dimensionLength = 2;
int dimension[2] = {2,3};
};
class TestRemoveIndex : public testing::Test {};
class TestReverseCopy : public testing::Test {};
class TestConcat : public testing::Test {};
class SliceVectorTest : public testing::Test {};
class SliceMatrixTest : public testing::Test {};
class SliceTensorTest : public testing::Test {};
class ElementWiseStrideTest : public testing::Test {
public:
Nd4jLong shape[3] = {3,4,5};
Nd4jLong stride[2] = {20,5};
int elementWiseStrideAssertion = -1;
};
class PermuteTest : public testing::Test{};
class LengthPerSliceTest : public testing::Test{};
class ExpectedValuesTest : public testing::Test {
public:
Nd4jLong mainShape[4] = {9,7,5,3};
int testDimensions[3] = {0,2,3};
};
class BeginOneTadTest : public testing::Test {
public:
Nd4jLong assertionShapeBuffer[8] = {2,3,5,1,3,16384,1,102};
Nd4jLong inputShapeBuffer[10] = {3,1,3,5,1,1,3,16384,0,102};
int dimensionLength = 2;
int dimension[2] = {1,2};
//error: [2,1,1,1,1,0,1,97]
};
class FourDTest : public testing::Test {
/**
* INDArray array3d = Nd4j.ones(1, 10, 10);
array3d.sum(1);
INDArray array4d = Nd4j.ones(1, 10, 10, 10);
INDArray sum40 = array4d.sum(0);
*/
public:
Nd4jLong threeDShape[3] = {1,10,10};
Nd4jLong fourDShape[4] = {1,10,10,10};
Nd4jLong *threeDShapeBuffer = nullptr,*fourDShapeBuffer = nullptr;
int dimensionThree = 1;
int dimensionThreeTwo = 0;
int dimensionFour = 0;
int dimensionLength = 1;
FourDTest() {
threeDShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'f', 3, threeDShape);
fourDShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'f', 4, fourDShape);
}
~FourDTest() {
if(threeDShapeBuffer != nullptr)
delete[] threeDShapeBuffer;
if(fourDShapeBuffer != nullptr)
delete[] fourDShapeBuffer;
}
};
TEST_F(FourDTest,ThreeDFourDTest) {
shape::TAD *threeTadTwo = new shape::TAD;
threeTadTwo->init(threeDShapeBuffer,&dimensionThreeTwo,dimensionLength);
threeTadTwo->createTadOnlyShapeInfo();
threeTadTwo->createOffsets();
shape::TAD *threeTad = new shape::TAD;
threeTad->init(threeDShapeBuffer,&dimensionThree,dimensionLength);
threeTad->createTadOnlyShapeInfo();
threeTad->createOffsets();
shape::TAD *fourTad = new shape::TAD;
fourTad->init(fourDShapeBuffer,&dimensionFour,dimensionLength);
fourTad->createTadOnlyShapeInfo();
fourTad->createOffsets();
delete threeTadTwo;
delete threeTad;
delete fourTad;
}
class RowVectorOnesTest : public testing::Test {
public:
Nd4jLong shapeBuffer[12] = {4,4,3,1,1,3,1,1,1,8192,1,99}; // float32 type of shape
float data[12] = {1,2,3,4,5,6,7,8,9,10,11,12};
Nd4jLong assertionBuffer[10] = {3,4,1,1,3,1,1,8192,0,99};
int dimensionLength = 3;
int dimension[3] = {0,2,3};
};
// TEST_F(RowVectorOnesTest,TadShape) {
// shape::TAD *tad = new shape::TAD(shapeBuffer,dimension,dimensionLength);
// tad->createTadOnlyShapeInfo();
// tad ->createOffsets();
// ASSERT_TRUE(arrsEquals(10,assertionBuffer,tad->tadOnlyShapeInfo));
// delete tad;
// }
class SixDTest : public testing::Test {
public:
Nd4jLong inputShapeBuffer[16] = {6,1,1,4,4,4,4,1,1,1,4,16,64,16384,1,102}; // shape with double data type
int dimensionLength = 2;
int dimension[2] = {2,3};
Nd4jLong assertionShapeBuffer[8] = {2,4,4,1,4,16384,1,102}; // also double typed shape
};
TEST_F(SixDTest, SixDWithOnes) {
shape::TAD *tad = new shape::TAD;
tad->init(inputShapeBuffer,dimension,dimensionLength);
tad->createTadOnlyShapeInfo();
tad->createOffsets();
// shape::printShapeInfoLinear(inputShapeBuffer);
// shape::printShapeInfoLinear(tad->tadOnlyShapeInfo);
//[2,1,1,1,1,0,1,97]
ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tad->tadOnlyShapeInfo));
delete tad;
}
class TrailingTest : public testing::Test {
public:
Nd4jLong inputShapeBuffer[12] = {4,5,5,5,1,1,5,25,125,16384,1,102};
int dimensionLength = 1;
int dimension[1] = {0};
Nd4jLong assertionShapeBuffer[8] = {2,1,5,125,1,16384,1,102};
};
TEST_F(TrailingTest,TrailingTest2) {
shape::TAD *tad = new shape::TAD;
tad->init(inputShapeBuffer,dimension,dimensionLength);
tad->createTadOnlyShapeInfo();
tad->createOffsets();
//[2,1,1,1,1,0,1,97]
ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tad->tadOnlyShapeInfo));
delete tad;
}
class ScalarTest : public testing::Test {
public:
Nd4jLong inputShapeBuffer[12] = {3,2,3,4,12,4,1,16384,1,99};
int dimensionLength = 1;
int dimension[1] = {1};
Nd4jLong assertionShapeBuffer[8] = {2,1,1,1,1,16384,1,99};
};
/*
TEST_F(ScalarTest,ScalarTest2) {
shape::TAD *tad = new shape::TAD(inputShapeBuffer,dimension,dimensionLength);
tad->createTadOnlyShapeInfo();
tad ->createOffsets();
//[2,1,1,1,1,0,1,97]
shape::printShapeInfoLinear(tad->tadOnlyShapeInfo);
ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tad->tadOnlyShapeInfo));
}
*/
class ThreeTest : public testing::Test {
public:
Nd4jLong inputShapeBuffer[10] = {3,4,3,2,6,2,1,16384,1,99};
int dimensionLength = 1;
int dimension[1] = {0};
Nd4jLong assertionShapeBuffer[8] = {2,1,4,1,6,16384,6,99};
};
TEST_F(ThreeTest,ThreeTest ) {
shape::TAD *tad = new shape::TAD;
tad->init(inputShapeBuffer,dimension,dimensionLength);
tad->createTadOnlyShapeInfo();
tad->createOffsets();
//[2,1,1,1,1,0,1,97]
ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tad->tadOnlyShapeInfo));
delete tad;
}
TEST_F(BeginOneTadTest, TadTest) {
shape::TAD *tad = new shape::TAD;
tad->init(inputShapeBuffer,dimension,dimensionLength);
tad->createTadOnlyShapeInfo();
auto tadShapeBuffer = tad->tadOnlyShapeInfo;
// shape::printShapeInfoLinear(tadShapeBuffer);
//[2,1,1,1,1,0,1,97]
ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tadShapeBuffer));
delete tad;
}
/*
TEST_F(OnesTest,OnesTadTest) {
shape::TAD *tad = new shape::TAD(shapeBuffer,dimension,dimensionLength);
int *tadShapeBuffer = tad->shapeInfoOnlyShapeAndStride();
ASSERT_TRUE(arrsEquals(10,tadAssertionShape,tadShapeBuffer));
delete[] tadShapeBuffer;
}
*/
TEST_F(LabelTest,LabelTad) {
shape::TAD *tad = new shape::TAD;
tad->init(shapeInfo,dimension,dimensionLength);
tad->createTadOnlyShapeInfo();
auto tadShapeInfo = tad->tadOnlyShapeInfo;
ASSERT_TRUE(arrsEquals(8,tadShapeInfoAssert,tadShapeInfo));
delete tad;
}
TEST_F(ExpectedValuesTest,TadTest) {
auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, mainShape);
shape::TAD *tad = new shape::TAD;
tad->init(shapeBuffer,testDimensions,3);
tad->createTadOnlyShapeInfo();
auto shapeInfo = tad->tadOnlyShapeInfo;
delete tad;
delete[] shapeBuffer;
}
TEST_F(OrderTest,testOrder) {
int rank = shape::rank(expected);
auto expectedShape = shape::shapeOf(expected);
auto expectedStride = shape::stride(expected);
int realOrder = shape::getOrder(rank,expectedShape,expectedStride,1);
int expectedOrder = 102;
ASSERT_EQ(expectedOrder,realOrder);
}
TEST_F(ThreeDTest,TensorAlongDimensionTest) {
int dimension[2] = {0,2};
Nd4jLong tadShapeAssertion[2] = {3,5};
Nd4jLong strideAssertion[2] = {20,1};
shape::TAD *tad = new shape::TAD;
tad->init(0,this->shapeBuffer,dimension,2);
tad->createTadOnlyShapeInfo();
auto shapeBufferTest = tad->tadOnlyShapeInfo;
auto shapeTest = shape::shapeOf(shapeBufferTest);
auto strideTest = shape::stride(shapeBufferTest);
ASSERT_TRUE(arrsEquals(2,tadShapeAssertion,shapeTest));
ASSERT_TRUE(arrsEquals(2,strideAssertion,strideTest));
delete tad;
}
TEST_F(NumTadTests,TadTest) {
auto shape = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, this->shape);
shape::TAD *tad = new shape::TAD;
tad->init(shape,&dimension,1);
int numTads = shape::tensorsAlongDimension(shape,&dimension,1);
ASSERT_EQ(20,numTads);
delete[] shape;
delete tad;
}
TEST_F(TADStall,TestStall) {
auto shapeInfo = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, shape);
shape::TAD *tad = new shape::TAD;
tad->init(0,shapeInfo,this->dimensions,3);
tad->createTadOnlyShapeInfo();
Nd4jLong *test = tad->tadOnlyShapeInfo;
delete[] shapeInfo;
delete tad;
}
TEST_F(LengthPerSliceTest,TestLengthPerSlice) {
Nd4jLong firstShape[2] = {5,3};
int lengthPerSliceAssertionFirst = 3;
int firstDimension = 0;
int lengthPerSliceTest = shape::lengthPerSlice(2,firstShape,&firstDimension,1);
ASSERT_EQ(lengthPerSliceAssertionFirst,lengthPerSliceTest);
}
TEST_F(PermuteTest,PermuteShapeBufferTest) {
int permuteOrder[4] = {3,2,1,0};
int normalOrder[4] = {0,1,2,3};
Nd4jLong shapeToPermute[4] = {5,3,2,6};
Nd4jLong permutedOrder[4] = {6,2,3,5};
auto shapeBufferOriginal = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, shapeToPermute);
auto assertionShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, shapeToPermute);
shape::permuteShapeBufferInPlace(shapeBufferOriginal,normalOrder,shapeBufferOriginal);
EXPECT_TRUE(arrsEquals(4,assertionShapeBuffer,shapeBufferOriginal));
auto backwardsAssertion = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, permutedOrder);
auto permuted = shape::permuteShapeBuffer(assertionShapeBuffer, permuteOrder);
EXPECT_TRUE(arrsEquals(4, backwardsAssertion, permuted));
delete[] permuted;
delete[] backwardsAssertion;
delete[] shapeBufferOriginal;
delete[] assertionShapeBuffer;
}
TEST_F(ElementWiseStrideTest,ElementWiseStrideTest) {
}
TEST_F(SliceVectorTest,RowColumnVectorTest) {
Nd4jLong rowVectorShape[2] = {1,5};
auto rowVectorShapeInfo = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, rowVectorShape);
Nd4jLong colVectorShape[2] = {5,1};
auto colVectorShapeInfo = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, colVectorShape);
Nd4jLong *sliceRow = shape::sliceOfShapeBuffer(0,rowVectorShapeInfo);
EXPECT_TRUE(arrsEquals(2,rowVectorShapeInfo,sliceRow));
Nd4jLong *scalarSliceInfo = shape::createScalarShapeInfo();
Nd4jLong *scalarColumnAssertion = shape::createScalarShapeInfo();
scalarColumnAssertion[shape::shapeInfoLength(2) - 3] = 1;
Nd4jLong *scalarColumnTest = shape::sliceOfShapeBuffer(1L,colVectorShapeInfo);
EXPECT_TRUE(arrsEquals(2,scalarColumnAssertion,scalarColumnTest));
delete[] scalarColumnTest;
delete[] scalarColumnAssertion;
delete[] scalarSliceInfo;
delete[] sliceRow;
delete[] rowVectorShapeInfo;
delete[] colVectorShapeInfo;
}
TEST_F(SliceTensorTest,TestSlice) {
Nd4jLong shape[3] = {3,3,2};
auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, shape);
Nd4jLong sliceShape[2] = {3,2};
auto sliceShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, sliceShape);
Nd4jLong *testSlice = shape::sliceOfShapeBuffer(0,shapeBuffer);
EXPECT_TRUE(arrsEquals(2,sliceShapeBuffer,testSlice));
delete[] testSlice;
delete[] shapeBuffer;
delete[] sliceShapeBuffer;
}
TEST_F(SliceMatrixTest,TestSlice) {
Nd4jLong shape[2] = {3,2};
auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, shape);
Nd4jLong sliceShape[2] = {1,2};
auto sliceShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, sliceShape);
Nd4jLong *testSlice = shape::sliceOfShapeBuffer(0,shapeBuffer);
EXPECT_TRUE(arrsEquals(2,sliceShapeBuffer,testSlice));
delete[] testSlice;
delete[] shapeBuffer;
delete[] sliceShapeBuffer;
}
TEST_F(TestConcat,ConcatTest) {
Nd4jLong firstArr[2] = {1,2};
Nd4jLong secondConcat[2] = {3,4};
Nd4jLong concatAssertion[4] = {1,2,3,4};
Nd4jLong *concatTest = shape::concat(firstArr,2,secondConcat,2);
EXPECT_TRUE(arrsEquals(4,concatAssertion,concatTest));
delete[] concatTest;
}
TEST_F(TestReverseCopy,ReverseCopyTest) {
Nd4jLong toCopy[5] = {0,1,2,3,4};
Nd4jLong reverseAssertion[5] = {4,3,2,1,0};
Nd4jLong *reverseCopyTest = shape::reverseCopy(toCopy,5);
EXPECT_TRUE(arrsEquals(5,reverseAssertion,reverseCopyTest));
delete[] reverseCopyTest;
}
TEST_F(TestRemoveIndex,Remove) {
Nd4jLong input[5] = {0,1,2,3,4};
Nd4jLong indexesToRemove[3] = {0,1,2};
Nd4jLong indexesToRemoveAssertion[2] = {3,4};
Nd4jLong *indexesToRemoveTest = shape::removeIndex<Nd4jLong>(input,indexesToRemove, (Nd4jLong) 5, (Nd4jLong) 3);
EXPECT_TRUE(arrsEquals(2,indexesToRemoveAssertion,indexesToRemoveTest));
delete[] indexesToRemoveTest;
}
TEST_F(TensorTwoFromFourDDimTest,TadTwoFromFourDimTest) {
//Along dimension 0,1: expect matrix with shape [rows,cols]
//Along dimension 0,2: expect matrix with shape [rows,dim2]
//Along dimension 0,3: expect matrix with shape [rows,dim3]
//Along dimension 1,2: expect matrix with shape [cols,dim2]
//Along dimension 1,3: expect matrix with shape [cols,dim3]
//Along dimension 2,3: expect matrix with shape [dim2,dim3]
auto baseShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, shape);
for(int i = 0; i < 3; i++) {
int *dimArr = dims[i];
Nd4jLong *expectedShape = expectedShapes[i];
shape::TAD *tad = new shape::TAD;
tad->init(baseShapeBuffer,dimArr,dimensionLength);
auto expectedShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', dimensionLength, expectedShape);
tad->createTadOnlyShapeInfo();
Nd4jLong *testShapeBuffer = tad->tadOnlyShapeInfo;
EXPECT_TRUE(arrsEquals(shape::rank(expectedShapeBuffer),expectedShape,shape::shapeOf(testShapeBuffer)));
EXPECT_TRUE(arrsEquals(shape::rank(expectedShapeBuffer),expectedStrides[i],shape::stride(testShapeBuffer)));
delete[] expectedShapeBuffer;
delete tad;
}
delete[] baseShapeBuffer;
}
TEST_F(TensorTwoDimTest,TadTwoDimTest) {
//Along dimension 0,1: expect matrix with shape [rows,cols]
//Along dimension 0,2: expect matrix with shape [rows,dim2]
//Along dimension 1,2: expect matrix with shape [cols,dim2]
auto baseShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, shape);
for(int i = 0; i < 3; i++) {
int *dimArr = dims[i];
Nd4jLong *expectedShape = expectedShapes[i];
shape::TAD *tad = new shape::TAD;
tad->init(baseShapeBuffer,dimArr,dimensionLength);
auto expectedShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', dimensionLength, expectedShape);
tad->createTadOnlyShapeInfo();
Nd4jLong *testShapeBuffer = tad->tadOnlyShapeInfo;
Nd4jLong *expectedStride = expectedStrides[i];
Nd4jLong *testShape = shape::shapeOf(testShapeBuffer);
Nd4jLong *testStride = shape::stride(testShapeBuffer);
EXPECT_TRUE(arrsEquals(shape::rank(expectedShapeBuffer),expectedShape,testShape));
EXPECT_TRUE(arrsEquals(shape::rank(testShapeBuffer),expectedStride,testStride));
delete[] expectedShapeBuffer;
delete tad;
}
delete[] baseShapeBuffer;
}
TEST_F(TensorOneDimTest,TadDimensionsForTensor) {
Nd4jLong shape[3] = {rows,cols,dim2};
auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', rank, shape);
for(int i = 0; i < rank; i++) {
//Along dimension 0: expect row vector with length 'dims[i]'
shape::TAD *zero = new shape::TAD;
zero->init(shapeBuffer,&dims[i],1);
zero->createTadOnlyShapeInfo();
Nd4jLong *testDimZeroShapeBuffer = zero->tadOnlyShapeInfo;
Nd4jLong *testShape = shape::shapeOf(testDimZeroShapeBuffer);
Nd4jLong *testStride = shape::stride(testDimZeroShapeBuffer);
EXPECT_TRUE(arrsEquals(2,expectedShapes[i],testShape));
EXPECT_TRUE(arrsEquals(2,expectedStrides[i],testStride));
delete zero;
}
delete[] shapeBuffer;
}
TEST_F(MatrixTest,TadDimensionsForMatrix) {
Nd4jLong shape[2] = {rows,cols};
auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', rank, shape);
shape::TAD *dimZero = new shape::TAD;
dimZero->init(shapeBuffer,&dims[0],1);
shape::TAD *dimOne = new shape::TAD;
dimOne->init(shapeBuffer,&dims[1],1);
//Along dimension 0: expect row vector with length 'rows'
Nd4jLong rowVectorShape[2] = {1,rows};
auto expectedDimZeroShape = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, rowVectorShape);
dimZero->createTadOnlyShapeInfo();
Nd4jLong *testDimZero = dimZero->tadOnlyShapeInfo;
EXPECT_TRUE(arrsEquals(2,expectedShapes[0],shape::shapeOf(testDimZero)));
EXPECT_TRUE(arrsEquals(2,expectedStrides[0],shape::stride(testDimZero)));
delete[] expectedDimZeroShape;
//Along dimension 1: expect row vector with length 'cols'
Nd4jLong rowVectorColShape[2] {1,cols};
auto expectedDimOneShape = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, rowVectorColShape);
dimOne->createTadOnlyShapeInfo();
Nd4jLong *testDimOneShape = dimOne->tadOnlyShapeInfo;
EXPECT_TRUE(arrsEquals(2,expectedShapes[1],shape::shapeOf(testDimOneShape)));
EXPECT_TRUE(arrsEquals(2,expectedStrides[1],shape::stride(testDimOneShape)));
delete[] expectedDimOneShape;
delete dimOne;
delete dimZero;
delete[] shapeBuffer;
}
TEST_F(VectorTest,VectorTadShape) {
Nd4jLong rowVector[2] = {2,2};
auto rowBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, rowVector);
int rowDimension = 1;
Nd4jLong columnVector[2] = {2,2};
auto colShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, columnVector);
int colDimension = 0;
shape::TAD *rowTad = new shape::TAD;
rowTad->init(rowBuffer,&rowDimension,1);
rowTad->createTadOnlyShapeInfo();
Nd4jLong *rowTadShapeBuffer = rowTad->tadOnlyShapeInfo;
Nd4jLong *rowTadShape = shape::shapeOf(rowTadShapeBuffer);
shape::TAD *colTad = new shape::TAD;
colTad->init(colShapeBuffer,&colDimension,1);
colTad->createTadOnlyShapeInfo();
Nd4jLong *colTadShapeBuffer = colTad->tadOnlyShapeInfo;
Nd4jLong *colTadShape = shape::shapeOf(colTadShapeBuffer);
Nd4jLong assertionShape[2] = {1,2};
Nd4jLong assertionStride[2] = {1,1};
EXPECT_TRUE(arrsEquals(2,assertionShape,rowTadShape));
EXPECT_TRUE(arrsEquals(2,assertionStride,shape::stride(rowTadShapeBuffer)));
EXPECT_TRUE(arrsEquals(2,assertionShape,colTadShape));
delete[] rowBuffer;
delete[] colShapeBuffer;
delete rowTad;
delete colTad;
}
TEST_F(ShapeTest,IsVector) {
ASSERT_TRUE(shape::isVector(vectorShape,2));
}
TEST_F(VectorTest,LinspaceCombinationTest) {
int rows = 3;
int cols = 4;
int len = rows * cols;
double *linspaced = linspace<double>(1,rows * cols,len);
Nd4jLong shape[2] = {rows,cols};
auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, shape);
delete[] shapeBuffer;
delete[] linspaced;
}