/* ****************************************************************************** * * * 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 #include "testinclude.h" #include #include 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(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(1,rows * cols,len); Nd4jLong shape[2] = {rows,cols}; auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, shape); delete[] shapeBuffer; delete[] linspaced; }