cavis/libnd4j/tests_cpu/layers_tests/DeclarableOpsTests5.cpp

/* ******************************************************************************
 *
 *
 * 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
 ******************************************************************************/

//
// @author raver119@gmail.com
//


#include "testlayers.h"
#include <ops/declarable/CustomOperations.h>
#include <helpers/helper_hash.h>
#include <array/NDArray.h>
#include <array/NDArrayList.h>


using namespace sd;
using namespace sd::graph;

class DeclarableOpsTests5 : public testing::Test {
public:

    DeclarableOpsTests5() {
        printf("\n");
        fflush(stdout);
    }
};


TEST_F(DeclarableOpsTests5, Test_PermuteEquality_1) {
    auto x = NDArrayFactory::create<double>('c', {1, 60});
    auto exp = NDArrayFactory::create<double>('c', {3, 5, 4}, {1.0, 6.0, 11.0, 16.0, 2.0, 7.0, 12.0, 17.0, 3.0, 8.0, 13.0, 18.0, 4.0, 9.0, 14.0, 19.0, 5.0, 10.0, 15.0, 20.0, 21.0, 26.0, 31.0, 36.0, 22.0, 27.0, 32.0, 37.0, 23.0, 28.0, 33.0, 38.0, 24.0, 29.0, 34.0, 39.0, 25.0, 30.0, 35.0, 40.0, 41.0, 46.0, 51.0, 56.0, 42.0, 47.0, 52.0, 57.0, 43.0, 48.0, 53.0, 58.0, 44.0, 49.0, 54.0, 59.0, 45.0, 50.0, 55.0, 60.0});
    x.linspace(1);
    x.reshapei('c', {3, 4, 5});

    sd::ops::permute op;
    auto result = op.evaluate({&x}, {}, {0, 2, 1});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

TEST_F(DeclarableOpsTests5, Test_PermuteEquality_0) {
    auto x = NDArrayFactory::create<double>('c', {1, 60});
    x.linspace(1);
    auto exp = NDArrayFactory::create<double>('c', {3, 4, 5}, {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0, 56.0, 57.0, 58.0, 59.0, 60.0});
    x.reshapei('c', {3, 4, 5});

//    x.printShapeInfo("{0, 1, 2} shape");
//    x.printBuffer("{0, 1, 2} data");

    sd::ops::permute op;
    auto result = op.evaluate({&x}, {}, {0, 1, 2});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}


TEST_F(DeclarableOpsTests5, Test_PermuteEquality_2) {
    auto x = NDArrayFactory::create<double>('c', {1, 60});
    x.linspace(1);
    auto exp = NDArrayFactory::create<double>('c', {4, 3, 5}, {1.0, 2.0, 3.0, 4.0, 5.0, 21.0, 22.0, 23.0, 24.0, 25.0, 41.0, 42.0, 43.0, 44.0, 45.0, 6.0, 7.0, 8.0, 9.0, 10.0, 26.0, 27.0, 28.0, 29.0, 30.0, 46.0, 47.0, 48.0, 49.0, 50.0, 11.0, 12.0, 13.0, 14.0, 15.0, 31.0, 32.0, 33.0, 34.0, 35.0, 51.0, 52.0, 53.0, 54.0, 55.0, 16.0, 17.0, 18.0, 19.0, 20.0, 36.0, 37.0, 38.0, 39.0, 40.0, 56.0, 57.0, 58.0, 59.0, 60.0});
    x.reshapei('c', {3, 4, 5});

//    x.printShapeInfo("{1, 0, 2} shape");
//    x.printBuffer("{1, 0, 2} data");

    sd::ops::permute op;
    auto result = op.evaluate({&x}, {}, {1, 0, 2});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

TEST_F(DeclarableOpsTests5, Test_PermuteEquality_3) {
    auto x = NDArrayFactory::create<double>('c', {1, 60});
    x.linspace(1);
    auto exp = NDArrayFactory::create<double>('c', {4, 5, 3}, {1.0, 21.0, 41.0, 2.0, 22.0, 42.0, 3.0, 23.0, 43.0, 4.0, 24.0, 44.0, 5.0, 25.0, 45.0, 6.0, 26.0, 46.0, 7.0, 27.0, 47.0, 8.0, 28.0, 48.0, 9.0, 29.0, 49.0, 10.0, 30.0, 50.0, 11.0, 31.0, 51.0, 12.0, 32.0, 52.0, 13.0, 33.0, 53.0, 14.0, 34.0, 54.0, 15.0, 35.0, 55.0, 16.0, 36.0, 56.0, 17.0, 37.0, 57.0, 18.0, 38.0, 58.0, 19.0, 39.0, 59.0, 20.0, 40.0, 60.0});
    x.reshapei('c', {3, 4, 5});

//    x.printShapeInfo("{1, 2, 0} shape");
//    x.printBuffer("{1, 2, 0} data");

    sd::ops::permute op;
    auto result = op.evaluate({&x}, {}, {1, 2, 0});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

TEST_F(DeclarableOpsTests5, Test_PermuteEquality_4) {
    auto x = NDArrayFactory::create<double>('c', {1, 60});
    x.linspace(1);
    auto exp = NDArrayFactory::create<double>('c', {5, 3, 4}, {1.0, 6.0, 11.0, 16.0, 21.0, 26.0, 31.0, 36.0, 41.0, 46.0, 51.0, 56.0, 2.0, 7.0, 12.0, 17.0, 22.0, 27.0, 32.0, 37.0, 42.0, 47.0, 52.0, 57.0, 3.0, 8.0, 13.0, 18.0, 23.0, 28.0, 33.0, 38.0, 43.0, 48.0, 53.0, 58.0, 4.0, 9.0, 14.0, 19.0, 24.0, 29.0, 34.0, 39.0, 44.0, 49.0, 54.0, 59.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0});
    x.reshapei('c', {3, 4, 5});

//    x.printShapeInfo("{2, 0, 1} shape");
//    x.printBuffer("{2, 0, 1} data");

    sd::ops::permute op;
    auto result = op.evaluate({&x}, {}, {2, 0, 1});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

TEST_F(DeclarableOpsTests5, Test_PermuteEquality_5) {
    auto x = NDArrayFactory::create<double>('c', {1, 60});
    x.linspace(1);
    auto exp = NDArrayFactory::create<double>('c', {5, 4, 3}, {1.0, 21.0, 41.0, 6.0, 26.0, 46.0, 11.0, 31.0, 51.0, 16.0, 36.0, 56.0, 2.0, 22.0, 42.0, 7.0, 27.0, 47.0, 12.0, 32.0, 52.0, 17.0, 37.0, 57.0, 3.0, 23.0, 43.0, 8.0, 28.0, 48.0, 13.0, 33.0, 53.0, 18.0, 38.0, 58.0, 4.0, 24.0, 44.0, 9.0, 29.0, 49.0, 14.0, 34.0, 54.0, 19.0, 39.0, 59.0, 5.0, 25.0, 45.0, 10.0, 30.0, 50.0, 15.0, 35.0, 55.0, 20.0, 40.0, 60.0});
    x.reshapei('c', {3, 4, 5});

//    x.printShapeInfo("{2, 1, 0} shape");
//    x.printBuffer("{2, 1, 0} data");

    sd::ops::permute op;
    auto result = op.evaluate({&x}, {}, {2, 1, 0});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

TEST_F(DeclarableOpsTests5, Test_TTS_bp_1) {
    auto x = NDArrayFactory::create<double>('c', {2, 1, 3});
    auto eps = NDArrayFactory::create<double>('c', {2, 4, 3});

    auto exp = NDArrayFactory::create<double>('c', {2, 1, 3}, {22.f, 26.f, 30.f, 70.f, 74.f, 78.f});

    eps.linspace(1.f);

    sd::ops::tile_to_shape_bp op;
    auto result = op.evaluate({&x, &eps}, {}, {2, 4, 3});

    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);
    // z->printShapeInfo("RES shape");
    // x.printShapeInfo("EXP shape");
    // z->printIndexedBuffer("RES output");
    ASSERT_TRUE(x.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}


TEST_F(DeclarableOpsTests5, Test_Rdiv_bp_1) {
    auto x = NDArrayFactory::create<double>('c', {3, 1}, {1, 2, 3});
    auto y = NDArrayFactory::create<double>('c', {1, 4}, {1, 2, 3, 4});
    auto eps = NDArrayFactory::create<double>('c', {3, 4}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});


    sd::ops::reversedivide op_ff;
    auto result_ff = op_ff.evaluate({&x, &y}, {}, {});
    ASSERT_EQ(Status::OK(), result_ff.status());

    auto z_ff = result_ff.at(0);
    ASSERT_TRUE(eps.isSameShape(z_ff));

    sd::ops::reversedivide_bp op_bp;
    auto result_bp = op_bp.evaluate({&x, &y, &eps}, {}, {});
    ASSERT_EQ(Status::OK(), result_bp.status());

    auto z_bp = result_bp.at(0);
    ASSERT_TRUE(x.isSameShape(z_bp));
}


TEST_F(DeclarableOpsTests5, Test_Boolean_diff_1) {
    auto x = NDArrayFactory::create<double>('c', {1, 1}, {1.0f});
    auto y = NDArrayFactory::create<double>(2.0f);

    sd::ops::less op;
    auto result = op.evaluate({&x, &y});
    ASSERT_EQ(Status::OK(), result.status());
    ASSERT_EQ(result.at(0)->t<bool>(0), true);

}

TEST_F(DeclarableOpsTests5, Test_SetSeed_1) {
    auto x = NDArrayFactory::create<int>('c', {1, 1}, {120});
    auto y = NDArrayFactory::create<int>(5);

    sd::ops::set_seed op;
    auto result = op.evaluate({&x, &y}, {}, {120, 5});

    ASSERT_EQ(Status::OK(), result.status());
//    result->at(0)->printIndexedBuffer("RES SEED");

    sd::ops::get_seed getOp;
    auto getRes = getOp.evaluate({});
    ASSERT_EQ(Status::OK(), getRes.status());
//    getres.at(0)->printIndexedBuffer("Output RES GET SEED");
//    ASSERT_EQ(result.at(0)->t<bool>(0), true);
}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, scatterMul_test1) {
    auto matrix = NDArrayFactory::create<float>('c', {2, 2}, {1.f, 2.f, 3.f, 4.f});
    NDArray idc('c', {1}, std::vector<double>({0LL}), sd::DataType::INT64);
    auto updates = NDArrayFactory::create<float>('c', {1, 2}, {10.f, 1.f});
    auto exp = NDArrayFactory::create<float>('c', {2, 2}, {10.f, 2.f, 3.f, 4.f});

    sd::ops::scatter_mul op;
    auto result = op.evaluate({&matrix, &idc, &updates}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.equalsTo(z));


}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, scatterDiv_test1) {
    auto matrix = NDArrayFactory::create<float>('c', {2, 2}, {1.f, 2.f, 3.f, 4.f});
    NDArray idc('c', {1}, std::vector<double>({0LL}), sd::DataType::INT64);
    auto updates = NDArrayFactory::create<float>('c', {1, 2}, {10.f, 1.f});
    auto exp = NDArrayFactory::create<float>('c', {2, 2}, {0.10f, 2.f, 3.f, 4.f});

    sd::ops::scatter_div op;
    auto result = op.evaluate({&matrix, &idc, &updates}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
//    z->printIndexedBuffer("Scatter Div");
    ASSERT_TRUE(exp.equalsTo(z));


}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, scatterSub_test1) {
    auto matrix = NDArrayFactory::create<float>('c', {2, 2}, {1.f, 2.f, 3.f, 4.f});
    NDArray idc('c', {1}, std::vector<double>({0LL}), sd::DataType::INT64);
    auto updates = NDArrayFactory::create<float>('c', {1, 2}, {10.f, 1.f});
    auto exp = NDArrayFactory::create<float>('c', {2, 2}, {-9.f, 1.f, 3.f, 4.f});

    sd::ops::scatter_sub op;
    auto result = op.evaluate({&matrix, &idc, &updates}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
//    z->printIndexedBuffer("Scatter Sub");
    ASSERT_TRUE(exp.equalsTo(z));


}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, hardsigmoid_test1) {
    auto matrix = NDArrayFactory::create<float>('c', {2, 2}, {1.f, 2.f, 3.f, 4.f});
    auto exp = NDArrayFactory::create<float>('c', {2, 2}, {0.7f, 0.9f, 1.f, 1.f});

    sd::ops::hardsigmoid op;
    auto result = op.evaluate({&matrix}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
    ASSERT_TRUE(exp.equalsTo(z));


}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, hardsigmoid_test2) {
    auto matrix = NDArrayFactory::create<float>('c', {2, 2}, {1.f, 2.f, 3.f, 4.f});
    auto eps = NDArrayFactory::create<float>('c', {2, 2}, {1.f, 2.f, 3.f, 4.f});
    auto exp = NDArrayFactory::create<float>('c', {2, 2}, {0.2f, 0.4f, 0.f, 0.f});

    sd::ops::hardsigmoid_bp op;
    auto result = op.evaluate({&matrix, &eps}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
    ASSERT_TRUE(exp.equalsTo(z));


}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, hardtanh_test1) {
    auto matrix = NDArrayFactory::create<double>('c', {3, 3}, {-4, -3, -2, -1, 0, 1, 2, 3, 4});
    auto exp = NDArrayFactory::create<double>('c', {3, 3}, {-1, -1, -1, -1, 0, 1, 1, 1, 1});

    sd::ops::hardtanh op;
    auto result = op.evaluate({&matrix}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
//    z->printIndexedBuffer("Hardtanh 2x2");
    ASSERT_TRUE(exp.equalsTo(z));


}
////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, hardtanh_test2) {
    auto matrix = NDArrayFactory::create<double>('c', {3, 3}, {-4, -3, -2, -1, 0, 1, 2, 3, 4});
    auto eps = NDArrayFactory::create<double>('c', {3, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9});
    auto exp = NDArrayFactory::create<double>('c', {3, 3}, {0, 0, 0, 4, 5, 6, 0, 0, 0});

    sd::ops::hardtanh_bp op;
    auto result = op.evaluate({&matrix, &eps}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
//    z->printIndexedBuffer("Hardtanh_bp 2x2");
    ASSERT_TRUE(exp.equalsTo(z));


}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, histogram_test1) {
    auto matrix = NDArrayFactory::create<double>('c', {3, 3}, {-4, -3, -2, -1, 0, 1, 2, 3, 4});
    auto exp = NDArrayFactory::create<Nd4jLong>('c', {3}, {3, 3, 3});

    sd::ops::histogram op;
    auto result = op.evaluate({&matrix}, {}, {3}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
//    z->printIndexedBuffer("Histogram3");
    ASSERT_TRUE(exp.equalsTo(z));


}
////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, histogram_test2) {
    auto matrix = NDArrayFactory::create<double>('c', {3}, {1, 2, 1});
    auto exp = NDArrayFactory::create<Nd4jLong>('c', {4}, {2, 0, 0, 1});

    sd::ops::histogram op;
    auto result = op.evaluate({&matrix}, {}, {4}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
    ASSERT_TRUE(exp.equalsTo(z));


}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Identity_test1) {
    auto matrix = NDArrayFactory::create<float>('c', {3, 3}, {-4.f, -3.f, -2.f, -1.f, 0.f, 1.f, 2.f, 3.f, 4.f});
//    auto exp = NDArrayFactory::create<Nd4jLong>('c', {3, 3}, {3, 3, 3});

    sd::ops::identity op;
    auto result = op.evaluate({&matrix}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
    ASSERT_TRUE(matrix.equalsTo(z));


}

////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Identity_test2) {
    auto matrix = NDArrayFactory::create<double>('c', {3, 3}, {-4, -3, -2, -1, 0, 1, 2, 3, 4});
    auto eps = NDArrayFactory::create<double>('c', {3, 3}, {1,2,3,4,5,6,7,8,9});
//    auto exp = NDArrayFactory::create<float>('c', {3,3});
    sd::ops::identity_bp op;
    auto result = op.evaluate({&matrix, &eps}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
    ASSERT_TRUE(z->equalsTo(eps));


}
////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Log1p_test1) {
    auto matrix = NDArrayFactory::create<double>('c', {3, 3}, {4, 3, 2, 1, 0, 1, 2, 3, 4});
    auto y = NDArrayFactory::create<double>('c', {3,3}, {5,4,3,2,1,2,3,4,5});
    //  auto eps = NDArrayFactory::create<float>('c', {3, 3}, {1,2,3,4,5,6,7,8,9});
//    auto exp = NDArrayFactory::create<float>('c', {3,3});
    sd::ops::Log1p op;
    y.applyTransform(sd::transform::Log, y);
    auto result = op.evaluate({&matrix}, {}, {}, {});
    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto z = result.at(0);
    ASSERT_TRUE(z->equalsTo(y));


}

TEST_F(DeclarableOpsTests5, Test_SpaceToBatch_1) {

    auto x = NDArrayFactory::create<double>('c', {1, 2, 2, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
    auto exp = NDArrayFactory::create<double>('c', {4, 1, 1, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
    auto paddings = NDArrayFactory::create<int>('c', {2, 2}, {0, 0, 0, 0});

    sd::ops::space_to_batch op;
    auto result = op.evaluate({&x, &paddings}, {}, {2});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}


TEST_F(DeclarableOpsTests5, Test_SpaceToBatch_2) {
    auto x = NDArrayFactory::create<double>('c', {1, 2, 2, 1}, {1, 2, 3, 4});
    auto exp = NDArrayFactory::create<double>('c', {4, 1, 1, 1}, {1, 2, 3, 4});
    auto paddings = NDArrayFactory::create<int>('c', {2, 2}, {0, 0, 0, 0});

    sd::ops::space_to_batch op;
    auto result = op.evaluate({&x, &paddings}, {}, {2});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}


TEST_F(DeclarableOpsTests5, Test_SpaceToBatch_3) {

    auto x = NDArrayFactory::create<double>('c', {2, 2, 4, 1}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16});
    auto paddings = NDArrayFactory::create<int>('c', {2, 2}, {0, 0, 2, 0});
    auto exp = NDArrayFactory::create<double>('c', {8, 1, 3, 1}, {0, 1, 3, 0,  9, 11,0, 2, 4, 0, 10, 12,0, 5, 7, 0, 13, 15,0, 6, 8, 0, 14, 16});

    sd::ops::space_to_batch op;
    auto result = op.evaluate({&x, &paddings}, {}, {2});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);
    // z->printIndexedBuffer();

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Test_SpaceToBatch_4) {

    const int blockSize = 2;
    NDArray x('c', {3, 3*blockSize - 1 - 2, 4*blockSize - 2 - 3, 2}, {147, 148, 219, 220, 149, 150, 11,  12, 83,  84, 13,  14, 155, 156, 227, 228, 157, 158, 171, 172, 243, 244, 173, 174, 35,  36, 107, 108, 37,  38, 179, 180, 251, 252, 181, 182, 195, 196, 267, 268, 197, 198, 59,  60, 131, 132, 61,  62, 203, 204, 275, 276, 205, 206}, sd::DataType::FLOAT32);
    NDArray paddings = NDArrayFactory::create<int>('c', {2, 2}, {1, 2, 2, 3});

    NDArray exp('c', {3*blockSize*blockSize, 3, 4, 2}, {0,0, 0,0, 0,0, 0,0, 0,0, 11,12, 13,14, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
        0,0, 0,0, 0,0, 35,36, 37,38, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 59,60, 61,62, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
        0,0, 0,0, 0,0, 0,0, 83,84, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 107, 108, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
        0,0, 0,0, 0,0, 0,0, 0,0, 131, 132, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 147, 148, 149, 150, 0,0, 0,0, 155, 156, 157, 158,
        0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 171, 172, 173, 174, 0,0, 0,0, 179, 180, 181, 182, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 195, 196,
        197, 198, 0,0, 0,0, 203, 204, 205, 206, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 219, 220, 0,0, 0,0, 0,0, 227, 228, 0,0, 0,0, 0,0,
        0,0, 0,0, 0,0, 0,0, 243, 244, 0,0, 0,0, 0,0, 251, 252, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 267, 268, 0,0, 0,0, 0,0, 275,
        276, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0}, sd::DataType::FLOAT32);

    sd::ops::space_to_batch op;
    auto result = op.evaluate({&x, &paddings}, {}, {blockSize});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);
    // z->printIndexedBuffer();

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

TEST_F(DeclarableOpsTests5, Test_BatchToSpace_1) {
    auto x = NDArrayFactory::create<double>('c', {4, 1, 1, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
    auto exp = NDArrayFactory::create<double>('c', {1, 2, 2, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
    auto crops = NDArrayFactory::create<int>('c', {2, 2}, {0, 0, 0, 0});

    sd::ops::batch_to_space op;
    auto result = op.evaluate({&x, &crops}, {}, {2});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);
    // z->printIndexedBuffer();

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

TEST_F(DeclarableOpsTests5, Test_BatchToSpace_2) {
    auto x = NDArrayFactory::create<double>('c', {4, 1, 1, 1}, {1, 2, 3, 4});
    auto exp = NDArrayFactory::create<double>('c', {1, 2, 2, 1}, {1, 2, 3, 4});
    auto crops = NDArrayFactory::create<int>('c', {2, 2}, {0, 0, 0, 0});

    sd::ops::batch_to_space op;
    auto result = op.evaluate({&x, &crops}, {}, {2});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}


TEST_F(DeclarableOpsTests5, Test_BatchToSpace_3) {
    auto x = NDArrayFactory::create<double>('c', {8, 1, 3, 1}, {0, 1, 3, 0,  9, 11,
                                                                0, 2, 4, 0, 10, 12,
                                                                0, 5, 7, 0, 13, 15,
                                                                0, 6, 8, 0, 14, 16});
    auto exp = NDArrayFactory::create<double>('c', {2, 2, 4, 1}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16});
    auto crops = NDArrayFactory::create<int>('c', {2, 2}, {0, 0, 2, 0});

    sd::ops::batch_to_space op;
    auto result = op.evaluate({&x, &crops}, {}, {2});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Test_BatchToSpace_4) {

    const int blockSize = 2;
    NDArray x('c', {3*blockSize*blockSize, 3, 4, 2}, sd::DataType::FLOAT32);
    x.linspace(1, 1);
    NDArray crops = NDArrayFactory::create<int>('c', {2, 2}, {1, 2, 2, 3});

    NDArray exp('c', {3, 3*blockSize - 1 - 2, 4*blockSize - 2 - 3, 2}, {147, 148, 219, 220, 149, 150, 11,  12, 83,  84, 13,  14, 155, 156, 227, 228, 157, 158, 171, 172, 243, 244, 173, 174, 35,  36, 107, 108, 37,  38, 179, 180, 251, 252, 181, 182, 195, 196, 267, 268, 197, 198, 59,  60, 131, 132, 61,  62, 203, 204, 275, 276, 205, 206}, sd::DataType::FLOAT32);

    sd::ops::batch_to_space op;
    auto result = op.evaluate({&x, &crops}, {}, {blockSize});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, eye_test1) {

    auto expected = NDArrayFactory::create<float>('c', {3, 3}, {1.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 1.f});

    sd::ops::eye op;
    auto results = op.evaluate({}, {}, {-99, 3});
    auto output = results.at(0);
    // output->printIndexedBuffer();

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, eye_test2) {

    auto expected = NDArrayFactory::create<float>('c', {3, 4}, {1.f,  0.f,  0.f,  0.f, 0.f,  1.f,  0.f,  0.f, 0.f,  0.f,  1.f,  0.f});

    sd::ops::eye op;
    auto results = op.evaluate({}, {}, {-99, 3, 4});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, eye_test3) {

    auto expected = NDArrayFactory::create<int>('c', {2, 3, 4}, {1,  0,  0,  0, 0,  1,  0,  0, 0,  0,  1,  0, 1,  0,  0,  0, 0,  1,  0,  0, 0,  0,  1,  0});

    sd::ops::eye op;
    auto results = op.evaluate({}, {9 /*int*/}, {-99, 3, 4, 2});
    auto output = results.at(0);
     // output->printIndexedBuffer("Output eye");

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, eye_test4) {

    auto expected = NDArrayFactory::create<double>('c', {2, 2, 3, 4}, {1.,  0.,  0.,  0., 0.,  1.,  0.,  0., 0.,  0.,  1.,  0., 1.,  0.,  0.,  0., 0.,  1.,  0.,  0., 0.,  0.,  1.,  0., 1.,  0.,  0.,  0., 0.,  1.,  0.,  0., 0.,  0.,  1.,  0., 1.,  0.,  0.,  0., 0.,  1.,  0.,  0., 0.,  0.,  1.,  0.});

    sd::ops::eye op;
    auto results = op.evaluate({}, {6/*double*/}, {-99, 3, 4, 2, 2});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, eye_test5) {

    sd::ops::eye op;
    auto result = op.evaluate({},{},{3, 2});

    auto z = result.at(0);
    ASSERT_EQ(ND4J_STATUS_OK, result.status());


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test1) {

    auto input = NDArrayFactory::create<double>('c', {4, 3, 2});
    input.linspace(1);
    auto indices = NDArrayFactory::create<int>('c', {2,2,1}, {3,2,3,2});

    auto expected = NDArrayFactory::create<double>('c', {2,2,3,2}, {19, 20, 21, 22, 23, 24, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 13, 14, 15, 16, 17, 18});

    sd::ops::gather_nd op;
    auto results = op.evaluate({&input, &indices}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test2) {

    auto input = NDArrayFactory::create<double>('c', {4, 3, 2});
    input.linspace(1);
    auto indices = NDArrayFactory::create<int>('c', {2,2,2}, {3,2,1,2, 0,1,0,1});

    auto expected = NDArrayFactory::create<double>('c', {2,2,2}, {23, 24, 11, 12, 3,  4, 3,  4});

    sd::ops::gather_nd op;
    auto results = op.evaluate({&input, &indices}, {}, {}, {true});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test3) {

    auto input = NDArrayFactory::create<double>('c', {4, 3, 2});
    input.linspace(1);
    auto indices = NDArrayFactory::create<int>('c', {3}, {3,2,1});
    auto expected = NDArrayFactory::create<double>(24.);

    sd::ops::gather_nd op;
    auto results = op.evaluate({&input, &indices}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test4) {

    auto input = NDArrayFactory::create<double>('c', {4, 3, 2});
    input.linspace(1);
    auto indices = NDArrayFactory::create<int>('c', {2,3}, {3,2,1,0,2,1});
    auto expected = NDArrayFactory::create<double>('c',{2}, {24., 6});

    sd::ops::gather_nd op;
    auto results = op.evaluate({&input, &indices}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test5) {

    auto input = NDArrayFactory::create<double>('c', {4}, {1,2,3,4});
    auto indices = NDArrayFactory::create<int>('c', {5,1}, {3,2,0,1,1});
    auto expected = NDArrayFactory::create<double>('c',{5}, {4.,3,1,2,2});

    sd::ops::gather_nd op;
    auto results = op.evaluate({&input, &indices}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test6) {

    auto input = NDArrayFactory::create<double>('c', {4}, {1,2,3,4});
    std::vector<Nd4jLong> shape = {1};
    auto indices = NDArrayFactory::create<int>('c', shape, {2});
    auto expected = NDArrayFactory::create<double>(3.);

    sd::ops::gather_nd op;
    auto results = op.evaluate({&input, &indices}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test7) {

    auto input = NDArrayFactory::create<double>('c', {4, 4});
    input.linspace(1);
    auto indices = NDArrayFactory::create<int>('c', {3,3,2}, {0,2,1, 0,1,0, 1,3,1, 0,2,1, 0,1,0, 1,3,1});
    auto expected = NDArrayFactory::create<double>('c', {3,3}, {3,5,5,8,5,10,2,2,14});

    sd::ops::gather_nd op;
    auto results = op.evaluate({&input, &indices}, {}, {}, {true});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test8) {
    auto x = NDArrayFactory::create<double>('c', {2, 2}, {1., 2., 3., 4.});
    auto y = NDArrayFactory::create<int>('c', {2, 2}, {0, 0, 1, 1});
    auto e = NDArrayFactory::create<double>('c', {2}, {1., 4.});

    sd::ops::gather_nd op;
    auto result = op.evaluate({&x, &y}, {}, {});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    ASSERT_EQ(e, *z);


}

TEST_F(DeclarableOpsTests5, gatherNd_test9) {
    auto x = NDArrayFactory::create<double>('c', {2, 4, 2, 2});
    auto indices = NDArrayFactory::create<int>('c', {3, 3}, {0,2,1, 0,1,0, 1,3,1});
    auto exp = NDArrayFactory::create<double>('c', {3,2}, {11.f, 12.f, 5.f, 6.f, 31.f, 32.f});
    x.linspace(1);

    sd::ops::gather_nd op;
    auto result = op.evaluate({&x, &indices}, {}, {});
    ASSERT_EQ(Status::OK(), result.status());

    auto z = result.at(0);

    //z->printIndexedBuffer();
    //z->printShapeInfo("z shape");

    ASSERT_TRUE(exp.isSameShape(z));
    ASSERT_TRUE(exp.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test10) {

    auto input = NDArrayFactory::create<double>('c', {4, 3, 2});
    auto indices = NDArrayFactory::create<int>('c', {2,2,2}, {30,20,1,2, 0,10,0,1});

    auto output = NDArrayFactory::create<double>('c', {2,2,2});

    sd::ops::gather_nd op;

    ASSERT_ANY_THROW(op.execute({&input, &indices}, {&output}, {}, {}, {true}));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, gatherNd_test11) {

    auto input = NDArrayFactory::create<double>('c', {4, 4});
    auto indices = NDArrayFactory::create<int>('c', {3,3,2}, {0,2,1, 0,10,0, 1,30,1, 0,20,1, 0,1,0, 1,30,1});
    auto output = NDArrayFactory::create<double>('c', {3,3});

    sd::ops::gather_nd op;

    ASSERT_ANY_THROW(op.execute({&input, &indices}, {&output}, {}, {}, {true}));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test1) {

    auto input = NDArrayFactory::create<double>('c', {3, 4, 5});
    input.linspace(1);
    auto seqLengths = NDArrayFactory::create<int>('c', {4}, {4,4,4,4});
    auto exp = NDArrayFactory::create<double>('c', {3, 4, 5}, {4,  3,  2,  1,  5, 9,  8,  7,  6, 10, 14, 13, 12, 11, 15, 19, 18, 17, 16, 20, 24, 23, 22, 21, 25, 29, 28, 27, 26, 30, 34, 33, 32, 31, 35, 39, 38, 37, 36, 40, 44, 43, 42, 41, 45, 49, 48, 47, 46, 50, 54, 53, 52, 51, 55, 59, 58, 57, 56, 60});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {2, 1});
    ASSERT_EQ(Status::OK(), results.status());

    auto output = results.at(0);

    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test2) {

    auto input = NDArrayFactory::create<double>('c', {3, 4, 5});
    input.linspace(1);
    auto seqLengths = NDArrayFactory::create<Nd4jLong>('c', {4}, {0,1,2,3});
    auto exp = NDArrayFactory::create<double>('c', {3, 4, 5}, {1,  2,  3,  4,  5, 6,  7,  8,  9, 10, 12, 11, 13, 14, 15, 18, 17, 16, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 32, 31, 33, 34, 35, 38, 37, 36, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 52, 51, 53, 54, 55, 58, 57, 56, 59, 60});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {2, 1});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test3) {

    auto input = NDArrayFactory::create<double>('c', {3, 4, 5});
    input.linspace(1);
    auto seqLengths = NDArrayFactory::create<int>('c', {3}, {2,3,4});
    auto exp = NDArrayFactory::create<double>('c', {3, 4, 5}, {2,  1,  3,  4,  5, 7,  6,  8,  9, 10, 12, 11, 13, 14, 15, 17, 16, 18, 19, 20, 23, 22, 21, 24, 25, 28, 27, 26, 29, 30, 33, 32, 31, 34, 35, 38, 37, 36, 39, 40, 44, 43, 42, 41, 45, 49, 48, 47, 46, 50, 54, 53, 52, 51, 55, 59, 58, 57, 56, 60});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {2, 0});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test4) {

    auto input = NDArrayFactory::create<double>('c', {3, 4, 5});
    input.linspace(1);
    auto seqLengths = NDArrayFactory::create<int>('c', {5}, {1, 2, 1, 2, 3});
    auto exp = NDArrayFactory::create<double>('c', {3, 4, 5}, {1, 22,  3, 24, 45, 6, 27,  8, 29, 50, 11, 32, 13, 34, 55, 16, 37, 18, 39, 60, 21,  2, 23,  4, 25, 26,  7, 28,  9, 30, 31, 12, 33, 14, 35, 36, 17, 38, 19, 40, 41, 42, 43, 44,  5, 46, 47, 48, 49, 10, 51, 52, 53, 54, 15, 56, 57, 58, 59, 20});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {0, 2});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test5) {

    auto input = NDArrayFactory::create<double>('c', {3, 4, 5});
    input.linspace(1);
    auto seqLengths = NDArrayFactory::create<int>('c', {5}, {1, 2, 4, 2, 3});
    auto exp = NDArrayFactory::create<double>('c', {3, 4, 5}, {1,  7, 18,  9, 15, 6,  2, 13,  4, 10, 11, 12,  8, 14,  5, 16, 17,  3, 19, 20, 21, 27, 38, 29, 35, 26, 22, 33, 24, 30, 31, 32, 28, 34, 25, 36, 37, 23, 39, 40, 41, 47, 58, 49, 55, 46, 42, 53, 44, 50, 51, 52, 48, 54, 45, 56, 57, 43, 59, 60});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {1, 2});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test6) {

    auto input = NDArrayFactory::create<double>('c', {3, 4, 5});
    input.linspace(1);
    auto seqLengths = NDArrayFactory::create<int>('c', {4}, {1, 2, 3, 2});
    auto exp = NDArrayFactory::create<double>('c', {3, 4, 5}, {1,  2,  3,  4,  5, 26, 27, 28, 29, 30, 51, 52, 53, 54, 55, 36, 37, 38, 39, 40, 21, 22, 23, 24, 25, 6,  7,  8,  9, 10, 31, 32, 33, 34, 35, 16, 17, 18, 19, 20, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 11, 12, 13, 14, 15, 56, 57, 58, 59, 60});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {0, 1});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test7) {

    auto input = NDArrayFactory::create<double>('c', {1, 5});
    input.linspace(1);
    std::vector<int> data = {3};
    auto seqLengths = NDArrayFactory::create<int>('c', {1}, data);
    auto exp = NDArrayFactory::create<double>('c', {1, 5}, {3, 2, 1, 4, 5});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {1, 0});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test8) {

    auto input = NDArrayFactory::create<double>('c', {1, 5});
    input.linspace(1);
    std::vector<int> data = {1,0,1,0,1};
    auto seqLengths = NDArrayFactory::create<int>('c', {5}, data);
    auto exp = NDArrayFactory::create<double>('c', {1, 5}, {1, 2, 3, 4, 5});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {0, 1});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test9) {

    auto input = NDArrayFactory::create<double>('c', {5, 1});
    input.linspace(1);
    std::vector<Nd4jLong> data = {1,0,1,0,1};
    auto seqLengths = NDArrayFactory::create<Nd4jLong>('c', {5}, data);
    auto exp = NDArrayFactory::create<double>('c', {5, 1}, {1, 2, 3, 4, 5});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {1, 0});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test10) {

    auto input = NDArrayFactory::create<double>('c', {5, 1});
    input.linspace(1);
    std::vector<int> data = {3};
    auto seqLengths = NDArrayFactory::create<int>('c', {1}, data);
    auto exp = NDArrayFactory::create<double>('c', {5, 1}, {3, 2, 1, 4, 5});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {0, 1});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test11) {

    auto input = NDArrayFactory::create<double>('c', {1, 1, 5, 1});
    input.linspace(1);
    std::vector<int> data = {1, 0, 1, 0, 1};
    auto seqLengths = NDArrayFactory::create<int>('c', {5}, data);
    auto exp = NDArrayFactory::create<double>('c', {1, 1, 5, 1}, {1, 2, 3, 4, 5});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {1, 2});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test12) {

    auto input = NDArrayFactory::create<double>('c', {1, 1, 5, 1});
    input.linspace(1);
    std::vector<int> data = {3};
    auto seqLengths = NDArrayFactory::create<int>('c', {1}, data);
    auto exp = NDArrayFactory::create<double>('c', {1, 1, 5, 1}, {3, 2, 1, 4, 5});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {2, 0});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test13) {

    auto input = NDArrayFactory::create<double>('c', {1, 1, 5, 1});
    input.linspace(1);
    std::vector<int> data = {1};
    auto seqLengths = NDArrayFactory::create<int>('c', {1}, data);
    auto exp = NDArrayFactory::create<double>('c', {1, 1, 5, 1}, {1, 2, 3, 4, 5});

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &seqLengths}, {}, {3, 0});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, reverse_sequense_test14) {
    auto input = NDArrayFactory::create<double>('c', {8, 8, 3, 2}, {0.09753360,             0.76124972,             0.24693797,             0.13813169,             0.33144656,             0.08299957,             0.67197708,             0.80659380,             0.98274191,             0.63566073,             0.21592326,             0.54902743,             0.54555996,             0.23407607,             0.11372584,             0.49965927,             0.15210842,             0.53268608,             0.38700677,             0.68832738,             0.37292716,             0.94616004,             0.77735792,             0.60803430,             0.61523204,             0.64298760,             0.26848351,             0.75015615,             0.28683049,             0.70937606,             0.06478678,             0.68985848,             0.55216783,             0.55382648,             0.34652863,             0.17261296,             0.54193264,             0.05176904,             0.82555761,             0.71106697,             0.04416722,             0.07653656,             0.01034390,             0.99430482,             0.59944390,             0.17973880,             0.36437840,             0.86383673,             0.45025550,             0.97136977,             0.13565978,             0.71567448,             0.92094825,             0.93536442,             0.93630291,             0.67277404,             0.93899264,             0.52422773,             0.44892176,             0.03127759,             0.85910449,             0.18252879,             0.72830945,             0.96736828,             0.89831575,             0.83437150,             0.59050780,             0.36145925,             0.16483070,             0.44021176,             0.76018652,             0.44227383,             0.13052339,             0.18204235,             0.99743733,             0.26885190,             0.87726522,             0.16396056,             0.94943412,             0.40016700,             0.65267938,             0.71073267,             0.40094733,             0.91182634,             0.05391789,             0.49520416,             0.24963864,             0.34847086,             0.74088617,             0.36115701,             0.63074210,             0.97423085,             0.42216846,             0.06326975,             0.07858702,             0.20586622,             0.28752144,             0.38146961,             0.83518735,             0.08207577,             0.82083487,             0.81665728,             0.33309570,             0.67563176,             0.98343578,             0.95919930,             0.66994391,             0.89296165,             0.34755773,             0.63166554,             0.18849320,             0.34828456,             0.98477707,             0.75163124,             0.83306004,             0.14203056,             0.01497920,             0.85727447,             0.71194544,             0.85654019,             0.86160433,             0.79580411,             0.47710411,             0.09318029,             0.31369071,             0.64122249,             0.58399725,             0.26706597,             0.05655339,             0.91025211,             0.30330468,             0.33142930,             0.05668627,             0.02936449,             0.12613087,             0.09960114,             0.16218074,             0.15088139,             0.31239040,             0.55980062,             0.34804391,             0.34941538,             0.61370555,             0.07022964,             0.59757058,             0.31189846,             0.25215345,             0.52546591,             0.55744218,             0.59485650,             0.60553664,             0.07536713,             0.55971796,             0.38764845,             0.20737843,             0.37989120,             0.18361641,             0.48636240,             0.06052657,             0.04241913,             0.66710351,             0.07007925,             0.59371493,             0.74479056,             0.84699625,             0.51210368,             0.12489571,             0.23371067,        
    auto lengths = NDArrayFactory::create<Nd4jLong>('c', {8}, {7, 2, 3, 5, 2, 1, 6, 4});
    auto e = NDArrayFactory::create<double>('c', {8, 8, 3, 2}, {0.54193264,             0.05176904,             0.82555761,             0.71106697,             0.04416722,             0.07653656,             0.06478678,             0.68985848,             0.55216783,             0.55382648,             0.34652863,             0.17261296,             0.61523204,             0.64298760,             0.26848351,             0.75015615,             0.28683049,             0.70937606,             0.38700677,             0.68832738,             0.37292716,             0.94616004,             0.77735792,             0.60803430,             0.54555996,             0.23407607,             0.11372584,             0.49965927,             0.15210842,             0.53268608,             0.67197708,             0.80659380,             0.98274191,             0.63566073,             0.21592326,             0.54902743,             0.09753360,             0.76124972,             0.24693797,             0.13813169,             0.33144656,             0.08299957,             0.01034390,             0.99430482,             0.59944390,             0.17973880,             0.36437840,             0.86383673,             0.93630291,             0.67277404,             0.93899264,             0.52422773,             0.44892176,             0.03127759,             0.45025550,             0.97136977,             0.13565978,             0.71567448,             0.92094825,             0.93536442,             0.85910449,             0.18252879,             0.72830945,             0.96736828,             0.89831575,             0.83437150,             0.59050780,             0.36145925,             0.16483070,             0.44021176,             0.76018652,             0.44227383,             0.13052339,             0.18204235,             0.99743733,             0.26885190,             0.87726522,             0.16396056,             0.94943412,             0.40016700,             0.65267938,             0.71073267,             0.40094733,             0.91182634,             0.05391789,             0.49520416,             0.24963864,             0.34847086,             0.74088617,             0.36115701,             0.63074210,             0.97423085,             0.42216846,             0.06326975,             0.07858702,             0.20586622,             0.34755773,             0.63166554,             0.18849320,             0.34828456,             0.98477707,             0.75163124,             0.33309570,             0.67563176,             0.98343578,             0.95919930,             0.66994391,             0.89296165,             0.28752144,             0.38146961,             0.83518735,             0.08207577,             0.82083487,             0.81665728,             0.83306004,             0.14203056,             0.01497920,             0.85727447,             0.71194544,             0.85654019,             0.86160433,             0.79580411,             0.47710411,             0.09318029,             0.31369071,             0.64122249,             0.58399725,             0.26706597,             0.05655339,             0.91025211,             0.30330468,             0.33142930,             0.05668627,             0.02936449,             0.12613087,             0.09960114,             0.16218074,             0.15088139,             0.31239040,             0.55980062,             0.34804391,             0.34941538,             0.61370555,             0.07022964,             0.27274571,             0.83306066,             0.75830824,             0.25963478,             0.87137718,             0.24418835,             0.59371493,             0.74479056,             0.84699625,             0.51210368,             0.12489571,             0.23371067,             0.18361641,             0.48636240,             0.06052657,             0.04241913,             0.66710351,             0.07007925,             0.60553664,             0.07536713,             0.55971796,             0.38764845,             0.20737843,             0.37989120,            

    sd::ops::reverse_sequence op;
    auto results = op.evaluate({&input, &lengths}, {}, {1, 0});
    ASSERT_EQ(Status::OK(), results.status());

    auto z = results.at(0);

    ASSERT_EQ(e, *z);


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Test_TopK_0) {
    auto x = NDArrayFactory::create<double>('c', {2, 6}, {1.0, 1.0, 1.0, 1.0, 11.0, 3.0, 1.0, 1.0, 1.0, 14.0, 5.0, 6.0});
    auto expV = NDArrayFactory::create<double>('c', {2, 1}, {11.0, 14.0});
    auto expI = NDArrayFactory::create<Nd4jLong>('c', {2, 1}, {4, 3});

    sd::ops::top_k op;
    auto result = op.evaluate({&x}, {}, {1, 0}); // without sorting

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto i = result.at(1);
/*
    v->printShapeInfo("topK_0: shape v");
    expV.printShapeInfo("topK_0: shape expV");

    i->printShapeInfo("topK_0: shape I");
    expI.printShapeInfo("topK_0: shape expI");

    v->printIndexedBuffer("topK_0: v");
    expV.printIndexedBuffer("topK_0: expV");
    i->printIndexedBuffer("topK_0: i");
    expI.printIndexedBuffer("topK_0: expI");
*/

    ASSERT_TRUE(expV.isSameShape(v));
    ASSERT_TRUE(expV.equalsTo(v));

    ASSERT_TRUE(expI.isSameShape(i));
    ASSERT_TRUE(expI.equalsTo(i));
    // repeat res again
    for (int cases = 0; cases < 100; ++cases) {
        op.execute({&x}, std::vector<NDArray*>{v, i}, {}, {1, 0}, {}); // without sorting
    }

}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Test_TopK_1) {
    auto x = NDArrayFactory::create<double>('c', {2, 3}, {1.0f, 11.0f, 3.0f, 14.0f, 5.0f, 6.0f});
    auto expV = NDArrayFactory::create<double>('c', {2, 1}, {11.0f, 14.0f});
    auto expI = NDArrayFactory::create<Nd4jLong>('c', {2, 1}, {1, 0});

    sd::ops::top_k op;
    auto result = op.evaluate({&x}, {}, {1, 0}); // without sorting

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto i = result.at(1);

//    v->printShapeInfo("topK_1: shape v");
//    expV.printShapeInfo("topK_1: shape expV");

//    i->printShapeInfo("topK_1: shape I");
//    expI.printShapeInfo("topK_1: shape expI");

//    v->printIndexedBuffer("topK_1: v");
//    expV.printIndexedBuffer("topK_1: expV");
//    i->printIndexedBuffer("topK_1: i");
//    expI.printIndexedBuffer("topK_1: expI");


    ASSERT_TRUE(expV.isSameShape(v));
    ASSERT_TRUE(expV.equalsTo(v));

    ASSERT_TRUE(expI.isSameShape(i));
    ASSERT_TRUE(expI.equalsTo(i));
    // repeat res again
    for (int cases = 0; cases < 100; ++cases) {
        op.execute({&x}, std::vector<NDArray*>{v, i}, {}, {1, 0}, {}); // without sorting
    }

}

///////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Test_TopK_2) {
    auto x = NDArrayFactory::create<double>('c', {2, 3, 4}, {11.0,  3.0, 14.0, 5.0,
                                      6.0,  9.0, 3.5, 7.0,
                                      21.0, 3.0, 14.0, 15.0,
                                      6.0, 9.0, 3.5, 7.0,
                                      11.0, 13.0, 14.0, 5.0,
                                      16.0, 9.0, 13.5, 7.0
                     }
    );
// <<<14.>,<9.>>, <<21.>,<9.>>, <<14.>,<16.>>>
    auto expV = NDArrayFactory::create<double>('c', {2, 3, 1}, {14.0f, 9.0f,
                                         21.0f,
                                         9.0f, 14.0f,
                                         16.0f
                        }
    );

    auto expI = NDArrayFactory::create<Nd4jLong>('c', {2, 3, 1 }, {2, 1, 0, 1, 2, 0});

    sd::ops::top_k op;
    auto result = op.evaluate({&x}, {}, {1, 1});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto i = result.at(1);

//    v->printShapeInfo("shape v");
//    expV.printShapeInfo("shape expV");

//    i->printShapeInfo("shape I");
//    expI.printShapeInfo("shape expI");

//    v->printIndexedBuffer("v");
//    expV.printIndexedBuffer("expV");
//    i->printIndexedBuffer("i");
//    expI.printIndexedBuffer("expI");

    ASSERT_TRUE(expV.isSameShape(v));
    ASSERT_TRUE(expV.equalsTo(v));

    ASSERT_TRUE(expI.isSameShape(i));
    ASSERT_TRUE(expI.equalsTo(i));


}

TEST_F(DeclarableOpsTests5, Test_TopK_3) {
    auto x = NDArrayFactory::create<double>('c', {2, 3, 4}, {11.0,  3.0, 14.0, 5.0,
                                      6.0,  9.0, 3.5, 7.0,
                                      21.0, 3.0, 14.0, 15.0,
                                      6.0, 9.0, 3.5, 7.0,
                                      11.0, 13.0, 14.0, 5.0,
                                      16.0, 9.0, 13.5, 7.0
                     }
    );

    auto expV = NDArrayFactory::create<double>('c', {2, 3, 2}, {14.0f, 11.0f,
                                                                9.0f, 7.0f,
                                                                21.0f, 15.0f,
                                         9.0f, 7.0f,
                                         14.0f, 13.0f,
                                         16.0f, 13.5f
                        }
    );

    auto expI = NDArrayFactory::create<Nd4jLong>('c', {2, 3, 2 }, {2, 0, 1, 3, 0, 3, 1,  3, 2, 1, 0, 2});

    sd::ops::top_k op;
    auto result = op.evaluate({&x}, {}, {2, 1});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto i = result.at(1);

//    v->printShapeInfo("shape v");
//    expV.printShapeInfo("shape expV");

//    i->printShapeInfo("shape I");
//    expI.printShapeInfo("shape expI");

//    v->printIndexedBuffer("v");
//    expV.printIndexedBuffer("expV");
//    i->printIndexedBuffer("i");
//    expI.printIndexedBuffer("expI");

    ASSERT_TRUE(expV.isSameShape(v));
    ASSERT_TRUE(expV.equalsTo(v));

    ASSERT_TRUE(expI.isSameShape(i));
    ASSERT_TRUE(expI.equalsTo(i));


}

TEST_F(DeclarableOpsTests5, Test_TopK_3_unsorted) {
    auto x = NDArrayFactory::create<double>('c', {2, 3, 4}, {11.0,  3.0, 14.0, 5.0,
                                                             6.0,  9.0, 3.5, 7.0,
                                                             21.0, 3.0, 14.0, 15.0,
                                                             6.0, 9.0, 3.5, 7.0,
                                                             11.0, 13.0, 14.0, 5.0,
                                                             16.0, 9.0, 13.5, 7.0
                                            }
    );

    auto expV = NDArrayFactory::create<double>('c', {2, 3, 2}, {11.0f, 14.0f,
                                                                9.0f, 7.0f,
                                                                21.0f, 15.0f,
                                                                9.0f, 7.0f,
                                                                13.0f, 14.0f,
                                                                16.0f, 13.5f
                                               }
    );

    auto expI = NDArrayFactory::create<Nd4jLong>('c', {2, 3, 2 }, {0, 2, 1, 3, 0, 3, 1,  3, 1, 2, 0, 2});

    sd::ops::top_k op;
    auto result = op.evaluate({&x}, {}, {2}, {false});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto i = result.at(1);

    ASSERT_TRUE(expV.isSameShape(v));
    ASSERT_TRUE(expV.equalsTo(v));

    ASSERT_TRUE(expI.isSameShape(i));
    ASSERT_TRUE(expI.equalsTo(i));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Test_TopK_4) {
    auto x = NDArrayFactory::create<double>('c', {2, 3}, {1.0f, 11.0f, 3.0f, 14.0f, 5.0f, 6.0f});
    auto expV = NDArrayFactory::create<double>('c', {2, 2}, {11.0f, 3.0f, 14.0f, 6.0f});
    auto expI = NDArrayFactory::create<Nd4jLong>('c', {2, 2}, {1, 2, 0, 2});

    sd::ops::top_k op;
    auto result = op.evaluate({&x}, {}, {2, 1});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto i = result.at(1);

    ASSERT_TRUE(expV.isSameShape(v));
    ASSERT_TRUE(expV.equalsTo(v));

    ASSERT_TRUE(expI.isSameShape(i));
    ASSERT_TRUE(expI.equalsTo(i));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Test_TopK_5) {
    auto x = NDArrayFactory::create<double>('f', {2, 3}, {1.1, 5.2, 3.1, 14.2, 11.1, 6.2});
    auto expV = NDArrayFactory::create<double>('f', {2, 2}, {11.1, 14.2, 3.1, 6.2});
    auto expI = NDArrayFactory::create<Nd4jLong>('f', {2, 2}, {2, 1, 1, 2});

    sd::ops::top_k op;
    auto result = op.evaluate({&x}, {}, {2, 1});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto i = result.at(1);

    ASSERT_TRUE(expV.isSameShape(v));
    ASSERT_TRUE(expV.equalsTo(v));

    ASSERT_TRUE(expI.isSameShape(i));
    ASSERT_TRUE(expI.equalsTo(i));


}

///////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, Test_Moments_1) {
    auto x = NDArrayFactory::create<double>('c', {2, 3, 4}, {11.0, 3.0, 14.0, 5.0,
                                   6.0, 9.0, 3.5, 7.0,
                                   21.0, 3.0, 14.0, 15.0,
                                   6.0, 9.0, 3.5, 7.0,
                                   11.0, 13.0, 14.0, 5.0,
                                   16.0, 9.0, 13.5, 7.0}
    );

    auto y = NDArrayFactory::create<double>('c', {3}, {0, 1, 2});
    //auto expV('f', {6}, {1, 0, 0, 0, 0, 0 });

    float expMean = 9.395833f;
    float expDeviation = 22.4579f;
//Mean 9.395833
//Deviance 22.4579

    float inf = 1.e-5f;

    sd::ops::moments op;
    auto result = op.evaluate({&x, &y}, {}, {});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto d = result.at(1);

//    v->printIndexedBuffer("Result is ");
//    d->printIndexedBuffer("Result is ");

    ASSERT_TRUE(v->isScalar());
    ASSERT_NEAR(expMean, v->e<double>(0), inf);
    ASSERT_NEAR(expDeviation, d->e<double>(0), inf);


}

TEST_F(DeclarableOpsTests5, Test_Moments_2) {
    NDArray x('c', {2, 3, 4}, {11.0, 3.0, 14.0, 5.0,
                                   6.0, 9.0, 3.5, 7.0,
                                   21.0, 3.0, 14.0, 15.0,
                                   6.0, 9.0, 3.5, 7.0,
                                   11.0, 13.0, 14.0, 5.0,
                                   16.0, 9.0, 13.5, 7.0}
    );

    NDArray expV('c', {4}, {11.833333, 7.6666665, 10.416667, 7.6666665});
    NDArray expD('c', {4}, {28.472221, 12.888889, 23.951387, 11.555554});

    sd::ops::moments op;
    auto result = op.evaluate({&x}, {}, {0, 1});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto d = result.at(1);

    ASSERT_TRUE(v->isVector());
    ASSERT_TRUE(d->isVector());

    ASSERT_TRUE(v->equalsTo(&expV));
    ASSERT_TRUE(d->equalsTo(&expD));


}

TEST_F(DeclarableOpsTests5, Test_Moments_3) {
    auto x = NDArrayFactory::create<double>('c', {2, 3, 4}, {11.0, 3.0, 14.0, 5.0,
                                   6.0, 9.0, 3.5, 7.0,
                                   21.0, 3.0, 14.0, 15.0,
                                   6.0, 9.0, 3.5, 7.0,
                                   11.0, 13.0, 14.0, 5.0,
                                   16.0, 9.0, 13.5, 7.0}
    );

    auto expV = NDArrayFactory::create<double>('c', {3, 4}, { 8.5f, 6.f , 8.75f,  6.f,
                                       8.5f, 11.f, 8.75f, 6.f,
                                      18.5f, 6.f, 13.75f, 11.f});
    auto expD = NDArrayFactory::create<double>('c', {3, 4}, { 6.25f, 9.f, 27.5625f,  1.f,
                                       6.25f, 4.f, 27.5625f,  1.f,
                                       6.25f, 9.f, 0.0625f,  16.f});

    sd::ops::moments op;
    auto result = op.evaluate({&x}, {}, {0});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto d = result.at(1);

    ASSERT_TRUE(v->isMatrix());
    ASSERT_TRUE(d->isMatrix());

    ASSERT_TRUE(v->equalsTo(&expV));
    ASSERT_TRUE(d->equalsTo(&expD));


}

TEST_F(DeclarableOpsTests5, Test_Moments_4) {

    auto x = NDArrayFactory::create<double>('f', {2, 3, 4}, {11.0f,  6.0f,  6.0f, 11.0f, 21.0f, 16.0f,  3.0f,  9.0f, 9.0f, 13.0f,  3.0f,  9.0f,
                                      14.0f,  3.5f,  3.5f, 14.0f, 14.0f,  13.5f,  5.0f,  7.0f, 7.0f,  5.0f, 15.0f,  7.0f});


    auto expV = NDArrayFactory::create<double>('c', {3, 4}, { 8.5f, 6.f , 8.75f,  6.f, 8.5f, 11.f, 8.75f, 6.f, 18.5f, 6.f, 13.75f, 11.f});
    auto expD = NDArrayFactory::create<double>('c', {3, 4}, { 6.25f, 9.f, 27.5625f,  1.f, 6.25f, 4.f, 27.5625f,  1.f, 6.25f, 9.f, 0.0625f,  16.f});

    sd::ops::moments op;
    auto result = op.evaluate({&x}, {}, {0});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(2, result.size());

    auto v = result.at(0);
    auto d = result.at(1);

    ASSERT_TRUE(v->isMatrix());
    ASSERT_TRUE(d->isMatrix());

    // v->printIndexedBuffer("v");
    // expV.printIndexedBuffer("expV");

    // d->printIndexedBuffer("d");
    // expD.printIndexedBuffer("expD");

    ASSERT_TRUE(v->equalsTo(&expV));
    ASSERT_TRUE(d->equalsTo(&expD));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, trace_test1) {

    auto input = NDArrayFactory::create<double>('c', {3, 4, 5});
    input.linspace(1);
    auto exp = NDArrayFactory::create<double>('c', {3}, {40, 120, 200});
    NDArray matrix('c', {3, 3}, {1., 2., 3., 4., 5., 6., 7., 8., 9.});
    sd::ops::trace op;
    auto results = op.evaluate({&input}, {}, {});
    auto output = results.at(0);
    double traceM = matrix.getTrace();
    // nd4j_printf("Trace for matrix is %f\n", traceM);
    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    // exp.printIndexedBuffer("EXP TRACE");
    // output->printIndexedBuffer("OUT TRACE");
    ASSERT_TRUE(exp.equalsTo(output));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, trace_test2) {

    auto input = NDArrayFactory::create<double>('c', {4, 5});
    input.linspace(1);
    auto exp = NDArrayFactory::create<double>(40.);

    sd::ops::trace op;
    auto results = op.evaluate({&input}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, trace_test3) {

    auto input = NDArrayFactory::create<double>('c', {1, 5});
    input.linspace(1);
    auto exp = NDArrayFactory::create<double>(1.);

    sd::ops::trace op;
    auto results = op.evaluate({&input}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, trace_test4) {

    auto input = NDArrayFactory::create<double>('c', {5, 1});
    input.linspace(1);
    auto exp = NDArrayFactory::create<double>(1.);

    sd::ops::trace op;
    auto results = op.evaluate({&input}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, trace_test5) {

    auto input = NDArrayFactory::create<double>('c', {3, 4, 5, 6});
    input.linspace(1);
    auto exp = NDArrayFactory::create<double>('c', {3, 4}, {75,  225,  375,  525, 675,  825,  975, 1125, 1275, 1425, 1575, 1725});

    sd::ops::trace op;
    auto results = op.evaluate({&input});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, random_shuffle_test1) {

    auto input = NDArrayFactory::create<double>('c', {2, 2, 2});
    input.linspace(1);
    NDArray exp1 = input.dup();
    NDArray exp2('c',{2,2,2}, {5,6,7,8,  1,2,3,4}, sd::DataType::DOUBLE);

    sd::ops::random_shuffle op;
    auto results = op.evaluate({&input});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(output->equalsTo(exp1) || output->equalsTo(exp2));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, random_shuffle_test2) {

    auto input = NDArrayFactory::create<double>('c', {1, 3, 2});
    input.linspace(1);
    NDArray exp1 = input.dup();

    sd::ops::random_shuffle op;
    auto results = op.evaluate({&input});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(output->equalsTo(exp1));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, random_shuffle_test3) {

    auto input = NDArrayFactory::create<double>('c', {3, 2, 1});
    input.linspace(1);
    NDArray exp1 = input.dup();
    NDArray exp2('c',{3,2,1}, {1,2, 5,6, 3,4}, sd::DataType::DOUBLE);
    NDArray exp3('c',{3,2,1}, {3,4, 1,2, 5,6}, sd::DataType::DOUBLE);
    NDArray exp4('c',{3,2,1}, {3,4, 5,6, 1,2}, sd::DataType::DOUBLE);
    NDArray exp5('c',{3,2,1}, {5,6, 1,2, 3,4}, sd::DataType::DOUBLE);
    NDArray exp6('c',{3,2,1}, {5,6, 3,4, 1,2}, sd::DataType::DOUBLE);

    sd::ops::random_shuffle op;
    auto results = op.evaluate({&input}, {},  {},  {}, {}, true);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(input.equalsTo(exp1) || input.equalsTo(exp2) || input.equalsTo(exp3)
             || input.equalsTo(exp4) || input.equalsTo(exp5) || input.equalsTo(exp6));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, random_shuffle_test4) {

    auto input = NDArrayFactory::create<double>('c', {3, 2, 1});
    input.linspace(1);
    NDArray exp1 = input.dup();
    NDArray exp2('c',{3,2,1}, {1,2, 5,6, 3,4}, sd::DataType::DOUBLE);
    NDArray exp3('c',{3,2,1}, {3,4, 1,2, 5,6}, sd::DataType::DOUBLE);
    NDArray exp4('c',{3,2,1}, {3,4, 5,6, 1,2}, sd::DataType::DOUBLE);
    NDArray exp5('c',{3,2,1}, {5,6, 1,2, 3,4}, sd::DataType::DOUBLE);
    NDArray exp6('c',{3,2,1}, {5,6, 3,4, 1,2}, sd::DataType::DOUBLE);

    sd::ops::random_shuffle op;
    auto results = op.evaluate({&input});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(output->equalsTo(exp1) || output->equalsTo(exp2) || output->equalsTo(exp3)
             || output->equalsTo(exp4) || output->equalsTo(exp5) || output->equalsTo(exp6));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, random_shuffle_test5) {
    auto input = NDArrayFactory::create<int>('c', {4});
    input.linspace(1);

    sd::ops::random_shuffle op;
    auto results = op.evaluate({&input}, {},  {},  {}, {}, false);
    auto output = results.at(0);
    // output->printBuffer();

    ASSERT_EQ(Status::OK(), results.status());
    // ASSERT_TRUE(!output->equalsTo(input));

    bool hasDublicates = false;
    for(int i = 0; i < output->lengthOf() - 1; ++i)
        for(int j = i+1; j < output->lengthOf(); ++j)
            if(output->t<int>(i) == output->t<int>(j)) {
                hasDublicates = true;
                i = output->lengthOf();
                break;
            }
    ASSERT_TRUE(!hasDublicates);
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, random_shuffle_test6) {
    auto input = NDArrayFactory::create<int>('c', {4,1,1});
    input.linspace(1);

    sd::ops::random_shuffle op;
    auto results = op.evaluate({&input}, {},  {},  {}, {}, false);
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    // ASSERT_TRUE(!output->equalsTo(input));

    bool hasDublicates = false;
    for(int i = 0; i < output->lengthOf() - 1; ++i)
        for(int j = i+1; j < output->lengthOf(); ++j)
            if(output->t<int>(i) == output->t<int>(j)) {
                hasDublicates = true;
                i = output->lengthOf();
                break;
            }
    ASSERT_TRUE(!hasDublicates);
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, random_shuffle_test7) {
    auto input = NDArrayFactory::create<int>('c', {16010});
    input.linspace(1);

    sd::ops::random_shuffle op;
    auto results = op.evaluate({&input}, {},  {},  {}, {}, false);
    auto output = results.at(0);
    // output->printBuffer();
    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(!output->equalsTo(input));

    auto vec1 = input.getBufferAsVector<int>();
    auto vec2 = output->getBufferAsVector<int>();
    std::sort(vec2.begin(), vec2.end());
    ASSERT_TRUE(std::equal(vec1.begin(), vec1.end(), vec2.begin()));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, random_shuffle_test8) {
    auto input = NDArrayFactory::create<int>('c', {1,4,1});
    input.linspace(1);
    NDArray inCopy = input.dup();

    sd::ops::random_shuffle op;
    auto results = op.evaluate({&input}, {},  {},  {}, {}, false);
    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(input.equalsTo(inCopy));

}

TEST_F(DeclarableOpsTests5, random_shuffle_test9) {

  auto x = NDArrayFactory::create<int>('c', {4}, {1, 2, 3, 4});
  auto z = x.ulike();

  sd::ops::random_shuffle op;
  auto status = op.execute({&x}, {&z});
  ASSERT_EQ(Status::OK(), status);

  auto vec = z.getBufferAsVector<int>();
  std::sort(vec.begin(), vec.end());
  ASSERT_EQ(std::vector<int>({1, 2, 3, 4}), vec);
}

////////////////////////////////////////////////////////////////////////////////////////

TEST_F(DeclarableOpsTests5, EmbeddingLookup_1) {

    auto x = NDArrayFactory::create<double>('c', {3, 4, 2}, {10, 20, 11, 21, 12, 22, 13, 23,
                                      14, 24, 15, 25, 16, 26, 17, 27,
                                      18, 28, 19, 29, 20, 30, 21, 31});

    auto y = NDArrayFactory::create<int>({1, 1, 1, 0, 0, 0, 2, 2, 2});
    auto exp = NDArrayFactory::create<double>('c', {9, 4, 2}, {14, 24, 15, 25, 16, 26, 17, 27, 14, 24, 15, 25,
                                        16, 26, 17, 27, 14, 24, 15, 25, 16, 26, 17, 27,
                                        10, 20, 11, 21, 12, 22, 13, 23, 10, 20, 11, 21,
                                        12, 22, 13, 23, 10, 20, 11, 21, 12, 22, 13, 23,
                                        18, 28, 19, 29, 20, 30, 21, 31, 18, 28, 19, 29,
                                        20, 30, 21, 31, 18, 28, 19, 29, 20, 30, 21, 31});

    // y.printShapeInfo("y shape");
    // y.printIndexedBuffer("y buffer");

    sd::ops::embedding_lookup op;
    auto result = op.evaluate({&x, &y}, {}, {0});
    auto output = result.at(0);
    // x.printShapeInfo("Input");
    output->printShapeInfo("Output");
    exp.printShapeInfo("Expected");
    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_TRUE(exp.isSameShape(output));
    //output->printIndexedBuffer("Output");
    //exp.printIndexedBuffer("Expect");

    ASSERT_TRUE(exp.equalsTo(output));


}

TEST_F(DeclarableOpsTests5, EmbeddingLookup_2) {

    auto x = NDArrayFactory::create<double>('c', {3, 4, 2}, {10, 20, 30, 40, 50, 60,
                                      70, 80, 90, 10, 11, 12,
                                      13, 14, 15, 16, 17, 18,
                                      19, 20, 21, 22, 23, 24});
                    //1,   0,   1,   0,   1,   0
    auto y = NDArrayFactory::create<Nd4jLong>({1, 0, 1, 0, 1, 0});
    auto exp = NDArrayFactory::create<double>('c', {6, 4, 2}, {90, 10, 11, 12, 13, 14,
                                        15, 16, 10, 20, 30, 40,
                                        50, 60, 70, 80, 90, 10,
                                        11, 12, 13, 14, 15, 16,
                                        10, 20, 30, 40, 50, 60,
                                        70, 80, 90, 10, 11, 12,
                                        13, 14, 15, 16, 10, 20,
                                        30, 40, 50, 60, 70, 80});

    // y.printShapeInfo("y shape");
    // y.printIndexedBuffer("y buffer");

    sd::ops::embedding_lookup op;
    auto result = op.evaluate({&x, &y}, {}, {0});
    auto output = result.at(0);
    // x.printShapeInfo("Input");
    // output->printShapeInfo("Output");
    // exp.printShapeInfo("Expected");
    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_TRUE(exp.isSameShape(output));
    // output->printIndexedBuffer("Output");
    // exp.printIndexedBuffer("Expect");

    ASSERT_TRUE(exp.equalsTo(output));


}

TEST_F(DeclarableOpsTests5, EmbeddingLookup_3) {


    auto y = NDArrayFactory::create<Nd4jLong>('c', {3,2}, {5, 4, 4, 5, 3, 3});
    auto exp = NDArrayFactory::create<double>('c', {6, 3, 3}, {
                6, 20, 11,    21, 12, 22,    13, 23, 14,
                5, 20, 11,    21, 12, 22,    13, 23, 14,
                5, 20, 11,    21, 12, 22,    13, 23, 14,
                6, 20, 11,    21, 12, 22,    13, 23, 14,
                4, 20, 11,    21, 12, 22,    13, 23, 14,
                4, 20, 11,    21, 12, 22,    13, 23, 14 });

    // y.printShapeInfo("y shape");
    // y.printIndexedBuffer("y buffer");
    auto p1 = NDArrayFactory::create<double>('c', {3,3}, {1, 20, 11, 21, 12, 22, 13, 23, 14});
    auto p2 = NDArrayFactory::create<double>('c', {3,3}, {2, 20, 11, 21, 12, 22, 13, 23, 14});
    auto p3 = NDArrayFactory::create<double>('c', {3,3}, {3, 20, 11, 21, 12, 22, 13, 23, 14});
    auto p4 = NDArrayFactory::create<double>('c', {3,3}, {4, 20, 11, 21, 12, 22, 13, 23, 14});
    auto p5 = NDArrayFactory::create<double>('c', {3,3}, {5, 20, 11, 21, 12, 22, 13, 23, 14});
    auto p6 = NDArrayFactory::create<double>('c', {3,3}, {6, 20, 11, 21, 12, 22, 13, 23, 14});
    auto p7 = NDArrayFactory::create<double>('c', {3,3}, {7, 20, 11, 21, 12, 22, 13, 23, 14});
    auto p8 = NDArrayFactory::create<double>('c', {3,3}, {8, 20, 11, 21, 12, 22, 13, 23, 14});

//    res = tf.nn.embedding_lookup((p1, p2, p3, p4, p5, p6, p7), ids, 'mod')

    sd::ops::embedding_lookup op;
    auto result = op.evaluate({&p1, &p2, &p3, &p4, &p5, &p6, &p7, &p8, &y}, {}, {1});
    auto output = result.at(0);
    // x.printShapeInfo("Input");
    // output->printIndexedBuffer("Output");
    // exp.printShapeInfo("Expected");
    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_TRUE(exp.isSameShape(output));
    // output->printIndexedBuffer("Output");
    // exp.printIndexedBuffer("Expect");

    ASSERT_TRUE(exp.equalsTo(output));


}
/* @Test
    public void testDynamicPartition(){
        INDArray data = Nd4j.createFromArray(2, 1, 2, 0);
        INDArray partitions = Nd4j.createFromArray(0, 2, 1, 0);
        INDArray[] out = Nd4j.exec(DynamicCustomOp.builder("dynamic_partition")
                .addOutputs(Nd4j.createUninitialized(DataType.INT, 2), Nd4j.createUninitialized(DataType.INT, 1), Nd4j.createUninitialized(DataType.INT, 1))
                .addIntegerArguments(3) //3 partitions
                .addInputs(data, partitions).build());

        INDArray exp0 = Nd4j.createFromArray(2, 0);
        INDArray exp1 = Nd4j.createFromArray(2);
        INDArray exp2 = Nd4j.createFromArray(1);

        assertEquals(exp0, out[0]);     //Usually just gives [0,0]
        assertEquals(exp1, out[1]);
        assertEquals(exp2, out[2]);
    }*/
TEST_F(DeclarableOpsTests5, DynamicPartition_01) {

    auto x = NDArrayFactory::create<int>({2,1,2,0});

    auto y = NDArrayFactory::create<int>({0,2,1,0});

    int numPartition = 3;
    std::vector<NDArray> exp( { NDArrayFactory::create<int>('c', {2}, {2, 0}),
                                NDArrayFactory::create<int>('c', {1}, {2}),
                                NDArrayFactory::create<int>('c', {1}, {1})});

    sd::ops::dynamic_partition op;
    auto result = op.evaluate({&x, &y}, {}, {numPartition});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(result.size(), numPartition); // result has the same size as given param 4

    for (int e = 0; e < result.size(); e++) {
        auto output = result.at(e);
        // output->printShapeInfo("Output shape> ");
        // output->printIndexedBuffer("Output data> ");
        ASSERT_TRUE(exp[e].isSameShape(output));
        ASSERT_TRUE(exp[e].equalsTo(output));
    }


}

TEST_F(DeclarableOpsTests5, DynamicPartition_1) {

    auto x = NDArrayFactory::create<double>('c', {3, 4, 2}, {10, 20, 11, 21, 12, 22,
                                      13, 23, 14, 24, 15, 25, 16, 26, 17, 27,
                                      18, 28, 19, 29, 20, 30, 21, 31});

    auto y = NDArrayFactory::create<int>('c', {3, 4, 2}, {0, 0, 0, 0, 0, 0,
                      2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
                      1, 1, 1, 1, 1, 1, 1, 1
                    }
    );
/*    auto y = NDArrayFactory::create<double>('c', {3, 4}, {0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
                      2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f,
                      1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f
                    }
    );
*/
    int numPartition = 3;
    std::vector<NDArray> exp( { NDArrayFactory::create<double>('c', {6}, {10, 20, 11, 21, 12, 22}),
                                NDArrayFactory::create<double>('c', {8}, {18, 28, 19, 29, 20, 30, 21, 31}),
                                NDArrayFactory::create<double>('c', {10}, {13, 23, 14, 24, 15, 25, 16, 26, 17, 27})});

    sd::ops::dynamic_partition op;
    auto result = op.evaluate({&x, &y}, {}, {numPartition});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(result.size(), numPartition); // result has the same size as given param 4

    for (int e = 0; e < result.size(); e++) {
        auto output = result.at(e);
        // output->printShapeInfo("Output shape> ");
        // output->printIndexedBuffer("Output data> ");
        ASSERT_TRUE(exp[e].isSameShape(output));
        ASSERT_TRUE(exp[e].equalsTo(output));
    }


}

////////////////////////////////////////////////////////////////////////////////

TEST_F(DeclarableOpsTests5, DynamicPartition_2) {

    auto x = NDArrayFactory::create<double>('c', {2, 4}, {0.1f, -1.f, 5.2f, 4.3f, -1.f, 7.4f, 0.0f, -2.2f});
    auto y = NDArrayFactory::create<int>('c', {2, 4}, {1, 2, 1, 2, 1, 2, 3, 0});

    std::vector<NDArray> exp( {NDArrayFactory::create<double>('c', {1}, {-2.2}),
                               NDArrayFactory::create<double>('c', {3}, {0.1, 5.2, -1.}),
                               NDArrayFactory::create<double>('c', {3}, {-1., 4.3, 7.4}),
                               NDArrayFactory::create<double>('c', {1}, {0.0})});

    sd::ops::dynamic_partition op;
    int numPartition = 4;
    auto result = op.evaluate({&x, &y}, {}, {numPartition});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(result.size(), numPartition); // result has the same size as given param 4

    for (int e = 0; e < result.size(); e++) {
        auto output = result.at(e);

        ASSERT_TRUE(exp[e].isSameShape(output));
        ASSERT_TRUE(exp[e].equalsTo(output));
    }


}


TEST_F(DeclarableOpsTests5, DynamicPartition_3) {

    auto x = NDArrayFactory::create<double>('c', {2, 4}, {0.1f, -1.f, 5.2f, 4.3f, -1.f, 7.4f, 0.0f, -2.2f});
    auto y = NDArrayFactory::create<Nd4jLong>('c', {2, 4}, {0, 1, 0, 2, 0, 2, 3, 0});

    std::vector<NDArray> exp( {NDArrayFactory::create<double>({0.1f, 5.2f, -1.f, -2.2f}),
                               NDArrayFactory::create<double>('c', {1}, {-1.f}),
                               NDArrayFactory::create<double>({4.3f, 7.4f}),
                               NDArrayFactory::create<double>('c', {1}, {0.0f})});

    sd::ops::dynamic_partition op;
    int numPartition = 4;
    auto result = op.evaluate({&x, &y}, {}, {numPartition});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());
    ASSERT_EQ(result.size(), numPartition); // result has the same size as given param 4

    for (int e = 0; e < result.size(); e++) {
        auto output = result.at(e);
        if (output)
        {
            // output->printShapeInfo("Output shape> ");
            // exp[e].printShapeInfo("Expected shape> ");
            // output->printIndexedBuffer("Output data> ");

            ASSERT_TRUE(exp[e].isSameShape(output));
            ASSERT_TRUE(exp[e].equalsTo(output));
        }
        else
        {
            ASSERT_TRUE(exp[e].lengthOf() == 0);
        }
    }


}

TEST_F(DeclarableOpsTests5, DynamicStitch_empty_1) {
    auto i0 = NDArrayFactory::create<int>('c', {2}, {2, 3});
    auto i1 = NDArrayFactory::empty<int>();
    auto i2 = NDArrayFactory::create<int>('c', {2}, {0, 1});

    auto d0 = NDArrayFactory::create<double>('c', {2, 5}, {0.085571885,0.7937801,0.65908563,0.55552566,0.15962744,0.7787856,0.80119777,0.72437465,0.23089433,0.72714126});
    auto d1 = NDArrayFactory::empty<double>();
    auto d2 = NDArrayFactory::create<double>('c', {2, 5}, {0.94414854,0.5956861,0.8668989,0.3502196,0.5100082,0.061725974,0.6621324,0.034165382,0.32576954,0.51917326});

    sd::ops::dynamic_stitch op;
    auto result = op.evaluate({&i0, &i1, &i2, &d0, &d1, &d2}, {}, {});
    ASSERT_EQ(Status::OK(), result.status());


}

TEST_F(DeclarableOpsTests5, DynamicStitch_empty_2) {
    auto i0 = NDArrayFactory::create<int>('c', {2}, {2, 3});
    auto i1 = NDArrayFactory::create<int>('c', {0});
    auto i2 = NDArrayFactory::create<int>('c', {2}, {0, 1});

    auto d0 = NDArrayFactory::create<double>('c', {2, 5}, {0.085571885,0.7937801,0.65908563,0.55552566,0.15962744,0.7787856,0.80119777,0.72437465,0.23089433,0.72714126});
    auto d1 = NDArrayFactory::create<double>('c', {0, 5});
    auto d2 = NDArrayFactory::create<double>('c', {2, 5}, {0.94414854,0.5956861,0.8668989,0.3502196,0.5100082,0.061725974,0.6621324,0.034165382,0.32576954,0.51917326});

    sd::ops::dynamic_stitch op;
    auto result = op.evaluate({&i0, &i1, &i2, &d0, &d1, &d2}, {}, {});
    ASSERT_EQ(Status::OK(), result.status());


}

////////////////////////////////////////////////////////////////////////////////

TEST_F(DeclarableOpsTests5, DynamicStitch_1) {

    auto x1 = NDArrayFactory::create<int>({1, 3, 5, 0});
    auto x2 = NDArrayFactory::create<int>({2, 4});
    auto y2 = NDArrayFactory::create<double>({-1., -1.});
    auto y1 = NDArrayFactory::create<double>({0.1f, 5.2f, 4.3f, 7.4f});


    auto exp = NDArrayFactory::create<double>({7.4f, 0.1f, -1.f, 5.2f, -1.f, 4.3f});

    sd::ops::dynamic_stitch op;
    auto result = op.evaluate({&x1, &x2, &y1, &y2}, {}, {});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

////////////////////////////////////////////////////////////////////////////////

TEST_F(DeclarableOpsTests5, DynamicStitch_2) {

    auto x1 = NDArrayFactory::create<int>({1, 3});
    auto x2 = NDArrayFactory::create<int>({5, 0, 2, 4});
    auto y1 = NDArrayFactory::create<double>({-1.f, -1.f});
    auto y2 = NDArrayFactory::create<double>({0.1f, 5.2f, 4.3f, 7.4f});


    auto exp = NDArrayFactory::create<double>({5.2f, -1.f, 4.3f, -1.f, 7.4f, 0.1f});

    sd::ops::dynamic_stitch op;
    auto result = op.evaluate({&x1, &x2, &y1, &y2}, {}, {});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    // output->printShapeInfo("Output shape> ");
    // exp.printShapeInfo("Expected shape> ");
    // output->printIndexedBuffer("Output data> ");
    // exp.printIndexedBuffer("Expected res>");
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, fusedBatchNorm_test1) {

    auto x = NDArrayFactory::create<double>('c', {2, 2, 3, 4});
    x.linspace(1);
    auto scale = NDArrayFactory::create<double>('c', {4});

    scale = 0.5;
    auto offset = NDArrayFactory::create<double>('c', {4});
    offset = 2.;
    auto expY = NDArrayFactory::create<double>('c', {2, 2, 3, 4}, {1.20337462,  1.20337462,  1.20337462,  1.20337462, 1.34821558,  1.34821558,  1.34821558,  1.34821558, 1.49305654,  1.49305654,  1.49305654,  1.49305654, 1.63789749,  1.63789749,  1.63789749,  1.63789749, 1.78273857,  1.78273857,  1.78273857,  1.78273857, 1.92757952,  1.92757952,  1.92757952,  1.92757952, 2.0724206 ,  2.0724206 ,  2.0724206 ,  2.0724206 , 2.21726155,  2.21726155,  2.21726155,  2.21726155, 2.36210251,  2.36210251,  2.36210251,  2.36210251, 2.50694346,  2.50694346,  2.50694346,  2.50694346, 2.65178442,  2.65178442,  2.65178442,  2.65178442, 2.79662538,  2.79662538,  2.79662538,  2.79662538});
    auto expBatchMean = NDArrayFactory::create<double>('c', {4}, {23.,  24.,  25.,  26.});
    auto expBatchVar = NDArrayFactory::create<double>('c', {4}, {208.00001526,  208.00001526,  208.00001526,  208.00001526});


    sd::ops::fused_batch_norm op;
    auto results = op.evaluate({&x, &scale, &offset}, {}, {0,1});
    auto y = results.at(0);
    auto batchMean = results.at(1);
    auto batchVar = results.at(2);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expY.isSameShape(y));
    ASSERT_TRUE(expBatchMean.isSameShape(batchMean));
    ASSERT_TRUE(expBatchVar.isSameShape(batchVar));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, fusedBatchNorm_test2) {

    auto x = NDArrayFactory::create<double>('c', {2, 2, 3, 4});
    x.linspace(1);

    auto scale = NDArrayFactory::create<double>('c', {4});

    scale = 0.5;
    auto offset = NDArrayFactory::create<double>('c', {4});
    offset = 2.;
    auto expY = NDArrayFactory::create<double>('c', {2, 2, 3, 4}, {1.20347691,  1.20347691,  1.20347691,  1.20347691, 1.34829926,  1.34829926,  1.34829926,  1.34829926, 1.49312162,  1.49312162,  1.49312162,  1.49312162, 1.6379441 ,  1.6379441 ,  1.6379441 ,  1.6379441 , 1.78276646,  1.78276646,  1.78276646,  1.78276646, 1.92758882,  1.92758882,  1.92758882,  1.92758882, 2.0724113 ,  2.0724113 ,  2.0724113 ,  2.0724113 , 2.21723366,  2.21723366,  2.21723366,  2.21723366, 2.36205602,  2.36205602,  2.36205602,  2.36205602, 2.50687838,  2.50687838,  2.50687838,  2.50687838, 2.65170074,  2.65170074,  2.65170074,  2.65170074, 2.79652309,  2.79652309,  2.79652309,  2.79652309});
    auto expBatchMean = NDArrayFactory::create<double>('c', {4}, {23.,  24.,  25.,  26.});
    auto expBatchVar = NDArrayFactory::create<double>('c', {4}, {208.00001526,  208.00001526,  208.00001526,  208.00001526});

    sd::ops::fused_batch_norm op;
    auto results = op.evaluate({&x, &scale, &offset}, {0.05}, {0,1});
    auto y = results.at(0);
    auto batchMean = results.at(1);
    auto batchVar = results.at(2);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expY.isSameShape(y));
    ASSERT_TRUE(expBatchMean.isSameShape(batchMean));
    ASSERT_TRUE(expBatchVar.isSameShape(batchVar));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, fusedBatchNorm_test3) {

    auto x = NDArrayFactory::create<double>('c', {2, 4, 2, 3});
    x.linspace(1);

    auto scale = NDArrayFactory::create<double>('c', {4});

    scale = 0.5;
    auto offset = NDArrayFactory::create<double>('c', {4});
    offset = 2.;
    auto expY = NDArrayFactory::create<double>('c', {2, 4, 2, 3}, {1.20337462,  1.20337462,  1.20337462,  1.20337462, 1.34821558,  1.34821558,  1.34821558,  1.34821558, 1.49305654,  1.49305654,  1.49305654,  1.49305654, 1.63789749,  1.63789749,  1.63789749,  1.63789749, 1.78273857,  1.78273857,  1.78273857,  1.78273857, 1.92757952,  1.92757952,  1.92757952,  1.92757952, 2.0724206 ,  2.0724206 ,  2.0724206 ,  2.0724206 , 2.21726155,  2.21726155,  2.21726155,  2.21726155, 2.36210251,  2.36210251,  2.36210251,  2.36210251, 2.50694346,  2.50694346,  2.50694346,  2.50694346, 2.65178442,  2.65178442,  2.65178442,  2.65178442, 2.79662538,  2.79662538,  2.79662538,  2.79662538});
    auto expBatchMean = NDArrayFactory::create<double>('c', {4}, {23.,  24.,  25.,  26.});
    auto expBatchVar = NDArrayFactory::create<double>('c', {4}, {208.00001526,  208.00001526,  208.00001526,  208.00001526});

    sd::ops::fused_batch_norm op;
    auto results = op.evaluate({&x, &scale, &offset}, {}, {1,1});
    auto y = results.at(0);
    auto batchMean = results.at(1);
    auto batchVar = results.at(2);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expY.isSameShape(y));
    ASSERT_TRUE(expBatchMean.isSameShape(batchMean));
    ASSERT_TRUE(expBatchVar.isSameShape(batchVar));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, fusedBatchNorm_test4) {

    auto x = NDArrayFactory::create<double>('c', {2, 2, 3, 4});
    x.linspace(1);
    std::vector<Nd4jLong> shape = {4};
    auto scale = NDArrayFactory::create<double>('c', shape);
    auto offset = NDArrayFactory::create<double>('c', shape);
    auto mean = NDArrayFactory::create<double>('c', shape);
    auto variance = NDArrayFactory::create<double>('c', shape);

    scale = 0.5;
    offset = 2.;
    mean = 25.;
    variance = 5.;

    auto expY = NDArrayFactory::create<double>('c', {2, 2, 3, 4}, {-3.36602688, -3.14244223, -2.91885757, -2.6952734 , -2.47168875, -2.24810457, -2.02451992, -1.80093551, -1.57735109, -1.35376668, -1.13018227, -0.90659785, -0.68301344, -0.45942879, -0.23584437, -0.01225996, 0.21132445,  0.43490887,  0.65849328,  0.88207781, 1.10566223,  1.32924664,  1.55283117,  1.77641559, 2.        ,  2.22358441,  2.44716883,  2.67075348, 2.89433765,  3.11792231,  3.34150672,  3.56509113, 3.78867555,  4.01225996,  4.23584461,  4.45942879, 4.68301344,  4.90659809,  5.13018227,  5.35376644, 5.57735109,  5.80093575,  6.02451992,  6.24810457, 6.47168875,  6.6952734 ,  6.91885757,  7.14244223});
    auto expBatchMean = NDArrayFactory::create<double>('c', shape, {0.,  0.,  0.,  0.});
    auto expBatchVar = NDArrayFactory::create<double>('c', shape, {0.,  0.,  0.,  0.});


    sd::ops::fused_batch_norm op;
    auto results = op.evaluate({&x, &scale, &offset}, {}, {0,1});
    auto y = results.at(0);
    auto batchMean = results.at(1);
    auto batchVar = results.at(2);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expY.isSameShape(y));
    ASSERT_TRUE(expBatchMean.isSameShape(batchMean));
    ASSERT_TRUE(expBatchVar.isSameShape(batchVar));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, fusedBatchNorm_test5) {

    auto x = NDArrayFactory::create<double>('c', {2, 2, 3, 4});
    x.linspace(1);
    std::vector<Nd4jLong> shape = {4};
    auto scale = NDArrayFactory::create<double>('c', shape);
    auto offset = NDArrayFactory::create<double>('c', shape);
    auto mean = NDArrayFactory::create<double>('c', shape);
    auto variance = NDArrayFactory::create<double>('c', shape);

    scale = 0.5;
    offset = 2.;
    mean = 25.;
    variance = 5.;

    auto expY = NDArrayFactory::create<double>('c', {2, 2, 3, 4}, {-3.33992958e+00,  -3.11743259e+00,  -2.89493513e+00,  -2.67243814e+00, -2.44994116e+00,  -2.22744417e+00,  -2.00494719e+00,  -1.78244996e+00, -1.55995297e+00,  -1.33745599e+00,  -1.11495876e+00,  -8.92461777e-01, -6.69964790e-01,  -4.47467566e-01,  -2.24970579e-01,  -2.47359276e-03, 2.20023513e-01,   4.42520618e-01,   6.65017605e-01,   8.87514710e-01, 1.11001182e+00,   1.33250880e+00,   1.55500591e+00,   1.77750289e+00, 2.00000000e+00,   2.22249699e+00,   2.44499421e+00,   2.66749120e+00, 2.88998818e+00,   3.11248541e+00,   3.33498240e+00,   3.55747938e+00, 3.77997637e+00,   4.00247383e+00,   4.22497082e+00,   4.44746780e+00, 4.66996479e+00,   4.89246178e+00,   5.11495876e+00,   5.33745575e+00, 5.55995274e+00,   5.78244972e+00,   6.00494719e+00,   6.22744417e+00, 6.44994116e+00,   6.67243814e+00,   6.89493513e+00,   7.11743259e+00});
    auto expBatchMean = NDArrayFactory::create<double>('c', shape, {0.,  0.,  0.,  0.});
    auto expBatchVar = NDArrayFactory::create<double>('c', shape, {0.,  0.,  0.,  0.});


    sd::ops::fused_batch_norm op;
    auto results = op.evaluate({&x, &scale, &offset}, {0.05}, {0,1});
    auto y = results.at(0);
    auto batchMean = results.at(1);
    auto batchVar = results.at(2);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expY.isSameShape(y));
    ASSERT_TRUE(expBatchMean.isSameShape(batchMean));
    ASSERT_TRUE(expBatchVar.isSameShape(batchVar));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, confusion_matrix_test1) {

    auto labels = NDArrayFactory::create<Nd4jLong>('c', {1, 3}, {1, 2, 4});
    auto predictions = NDArrayFactory::create<Nd4jLong>('c', {1, 3}, {2, 2, 4});
    auto expected = NDArrayFactory::create<Nd4jLong>('c', {5, 5}, {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1});

    sd::ops::confusion_matrix op;
    auto results = op.evaluate({&labels, &predictions}, {}, {});
    ASSERT_EQ(Status::OK(), results.status());

    auto output = results.at(0);

    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, confusion_matrix_test2) {

    auto labels = NDArrayFactory::create<Nd4jLong>('c', {1, 2}, {1, 2});
    auto predictions = NDArrayFactory::create<Nd4jLong>('c', {1, 2}, {0, 2});
    auto expected = NDArrayFactory::create<Nd4jLong>('c', {3, 3}, {0, 0, 0, 1, 0, 0, 0, 0, 1});

    sd::ops::confusion_matrix op;
    auto results = op.evaluate({&labels, &predictions}, {}, {3});
    ASSERT_EQ(Status::OK(), results.status());

    auto output = results.at(0);

    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, confusion_matrix_test3) {

    auto labels = NDArrayFactory::create<Nd4jLong>('c', {1, 2}, {1, 2});
    auto predictions = NDArrayFactory::create<Nd4jLong>('c', {1, 2}, {0, 2});
    auto weights = NDArrayFactory::create<Nd4jLong>('c', {1, 2}, {100, 200});
    auto expected = NDArrayFactory::create<Nd4jLong>('c', {3, 3}, {0, 0, 0, 100, 0, 0, 0, 0, 200});

    sd::ops::confusion_matrix op;
    auto results = op.evaluate({&labels, &predictions, &weights}, {}, {3});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, confusion_matrix_test4) {

    auto labels = NDArrayFactory::create<int>('c', {1, 2}, {1, 2});
    auto predictions = NDArrayFactory::create<int>('c', {1, 2}, {0, 2});
    auto weights = NDArrayFactory::create<double>('c', {1, 2}, {100, 200});
    auto expected = NDArrayFactory::create<double>('c', {3, 3}, {0, 0, 0, 100, 0, 0, 0, 0, 200});

    sd::ops::confusion_matrix op;
    auto results = op.evaluate({&labels, &predictions, &weights}, {}, {3}, {}, {sd::DataType::DOUBLE});
    auto output = results.at(0);


    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expected.isSameShape(output));
    ASSERT_TRUE(expected.equalsTo(output));


}

///////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, ZeroFraction_1) {

    auto x = NDArrayFactory::create<double>('c', {3, 4, 2}, {0, 20, 30, 0, 50, 0,
                                      70, 0, 90, 0, 11, 12,
                                      13, 14, 15, 16, 17, 18,
                                      19, 0, 21, 22, 23, 24});

    sd::ops::zero_fraction op;
    auto res = op.evaluate({&x}, {}, {});

    ASSERT_EQ(Status::OK(), res.status());
    ASSERT_TRUE(res.at(0)->isScalar());
    ASSERT_EQ(res.at(0)->e<double>(0), 0.25);


}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, ZeroFraction_2) {

    auto x = NDArrayFactory::create<double>('c', {2, 2, 2}, {5.5, 0., 0.3, 5.5, 8.6, 0., 0., 0.4});

    sd::ops::zero_fraction op;
    auto res = op.evaluate({&x}, {}, {});

    ASSERT_EQ(Status::OK(), res.status());
    ASSERT_TRUE(res.at(0)->isScalar());
    ASSERT_EQ(res.at(0)->e<double>(0), 0.375);


}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, ZeroFraction_3) {

    auto x = NDArrayFactory::create<double>('f', {2, 2, 2}, {5.5, 0., 0.3, 5.5, 8.6, 0., 0., 0.4});

    sd::ops::zero_fraction op;
    auto res = op.evaluate({&x}, {}, {});

    ASSERT_EQ(Status::OK(), res.status());
    ASSERT_TRUE(res.at(0)->isScalar());
    ASSERT_EQ(res.at(0)->e<double>(0), 0.375);


}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, XWPlusB_1) {

    auto x = NDArrayFactory::create<float>('c', { 2,3 }, { 1.f, 11.f,  3.f, 14.f,  5.f,  6.f });
    auto y = NDArrayFactory::create<float>('c', { 3,2 }, { 11.f,  3.f, 4.f,  5.f, 6.f,  2.f });
    auto b = NDArrayFactory::create<float>({ 100.f, 200.f });

    auto exp = NDArrayFactory::create<float>('c', { 2,2 }, { 173.f, 264.f, 310.f, 279.f });

    sd::ops::xw_plus_b op;
    auto result = op.evaluate({ &x, &y, &b });

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, XWPlusB_2) {

    auto x = NDArrayFactory::create<float>('c', { 1, 2 }, { 1.f, 11.f });
    auto y = NDArrayFactory::create<float>('c', { 2, 3 }, { 11.f,  3.f, 4.f,  5.f, 6.f,  2.f });
    auto b = NDArrayFactory::create<float>({ 100.f, 200.f, 300.f });

    auto exp = NDArrayFactory::create<float>('c', { 1, 3 }, { 166.f, 269.f, 326.f });

    sd::ops::xw_plus_b op;
    auto result = op.evaluate({ &x, &y, &b }, {}, {});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));

}
////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, XWPlusB_3) {

    auto x = NDArrayFactory::create<float>('c', { 1, 2 }, { 1.f, 11.f });
    auto y = NDArrayFactory::create<float>('c', { 2, 1 }, { 11.f,  3.f });
    auto b = NDArrayFactory::create<float>('c', { 1 }, { 200.f });

    auto exp = NDArrayFactory::create<float>('c', { 1,1 }, { 244.f });

    sd::ops::xw_plus_b op;
    auto result = op.evaluate({ &x, &y, &b });

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}
////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, XWPlusB_4) {

    auto x = NDArrayFactory::create<float>('f', { 2,3 }, { 1.f, 11.f,  3.f, 14.f,  5.f,  6.f });
    auto y = NDArrayFactory::create<float>('f', { 3,2 }, { 11.f,  3.f, 4.f,  5.f, 6.f,  2.f });
    auto b = NDArrayFactory::create<float>({ 100.f, 200.f });

    auto exp = NDArrayFactory::create<float>('f', { 2,2 }, { 140.f, 287.f, 233.f,  351.f });

    sd::ops::xw_plus_b op;
    auto result = op.evaluate({ &x, &y, &b });

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}
////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, XWPlusB_5) {

    auto x = NDArrayFactory::create<float>('c', { 2,3 }, { 1.f, 11.f,  3.f, 14.f,  5.f,  6.f });
    auto y = NDArrayFactory::create<float>('c', { 3,2 }, { 11.f,  3.f, 4.f,  5.f, 6.f,  2.f });

    y = y.transpose();

    auto b = NDArrayFactory::create<float>({ 100.f, 200.f });

    auto exp = NDArrayFactory::create<float>('c', { 2,2 }, { 173.f, 264.f, 310.f, 279.f });


    sd::ops::xw_plus_b op;
    auto result = op.evaluate({ &x, &y, &b }, {}, { 1 });

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}
////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, XWPlusB_6) {

    auto x = NDArrayFactory::create<float>('c', { 3, 2 }, { 1.f, 11.f,  3.f, 14.f,  5.f,  6.f });
    auto y = NDArrayFactory::create<float>('c', { 2, 1 }, { 11.f,  3.f });

    auto b = NDArrayFactory::create<float>('c', { 1 }, { 100.f });

    auto exp = NDArrayFactory::create<float>('c', { 3, 1 }, { 144.f, 175.f, 173.f });

    sd::ops::xw_plus_b op;
    auto result = op.evaluate({ &x, &y, &b });

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}
////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, XWPlusB_7) {

    auto x = NDArrayFactory::create<float>('c', { 3, 4 }, { 1.f, 11.f,  3.f, 14.f,  5.f,  6.f, 1.f, 11.f,  3.f, 14.f,  5.f,  6.f });
    auto y = NDArrayFactory::create<float>('c', { 4, 5 }, { 11.f,  3.f, 11.f,  3.f, 11.f,  3.f, 11.f,  3.f, 11.f,  3.f, 11.f,  3.f, 11.f,  3.f, 11.f,  3.f, 3.f, 11.f, 3.f, 11.f });

    auto b = NDArrayFactory::create<float>('c', { 5 }, { 100.f, 200.f, 300.f, 400.f, 500.f });

    auto exp = NDArrayFactory::create<float>('c', { 3, 5 }, { 219.f, 375.f, 531.f, 575.f, 731.f, 217.f, 317.f, 505.f, 517.f, 705.f, 248.f, 396.f, 496.f, 596.f, 696.f });

    sd::ops::xw_plus_b op;
    auto result = op.evaluate({ &x, &y, &b });

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));
}
////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, StopGradient_1) {

    auto x = NDArrayFactory::create<double>('c', {2,3}, { 1.f, 11.f,  3.f, 14.f,  5.f,  6.f});

    sd::ops::stop_gradient op;
    auto result = op.evaluate({&x});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    // output->printShapeInfo("Output shape> ");
    // x.printShapeInfo("Expected shape> ");
    // output->printIndexedBuffer("Output data> ");
    // x.printIndexedBuffer("Expected res>");

    ASSERT_TRUE(x.isSameShape(output));
    ASSERT_TRUE(x.equalsTo(output));


}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, StopGradient_2) {

    auto x = NDArrayFactory::create<double>('f', {2,3}, { 1.f, 11.f,  3.f, 14.f,  5.f,  6.f});

    sd::ops::stop_gradient op;
    auto result = op.evaluate({&x});

    ASSERT_EQ(ND4J_STATUS_OK, result.status());

    auto output = result.at(0);

    // output->printShapeInfo("Output shape> ");
    // x.printShapeInfo("Expected shape> ");
    // output->printIndexedBuffer("Output data> ");
    // x.printIndexedBuffer("Expected res>");

    ASSERT_TRUE(x.isSameShape(output));
    ASSERT_TRUE(x.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test1) {

    auto input = NDArrayFactory::create<double>('c', {3, 3, 3}, {-1, 1, -2, 2, -3, 3, -4, 4, -5,5 ,-6,6, -7,7, -8,8, -9,9, -10,10, -11,11, -12,12, -13,13, 14});
    auto expOutput = NDArrayFactory::create<double>('c', {3, 3, 3}, {-2.16985e+00,-1.69846e-01,-3.16985e+00, -1.31507e+00,-6.31507e+00,-3.15072e-01, -8.00046e+00,-4.58767e-04,-9.00046e+00, -1.31327e+00,-1.23133e+01,-3.13266e-01, -1.40000e+01,-1.13743e-06,-1.50000e+01, -1.31326e+00,-1.83133e+01,-3.13262e-01, -2.00000e+01,-2.81941e-09,-2.10000e+01, -1.31326e+00,-2.43133e+01,-3.13262e-01, -2.73133e+01,-1.31326e+00,-3.13262e-01});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test2) {

    auto input = NDArrayFactory::create<double>('c', {3, 3, 3}, {-1, 1, -2, 2, -3, 3, -4, 4, -5,5 ,-6,6, -7,7, -8,8, -9,9, -10,10, -11,11, -12,12, -13,13, 14});
    auto expOutput = NDArrayFactory::create<double>('c', {3, 3, 3}, {-3.05095e+00,-3.04946e+00,-5.00705e+00, -5.09458e-02,-7.04946e+00,-7.04851e-03, -6.05095e+00,-4.94556e-02,-8.00705e+00, -3.04859e+00,-1.30000e+01,-3.04859e+00, -1.50486e+01,-2.37286e-06,-1.70486e+01, -4.85876e-02,-1.60000e+01,-4.85874e-02, -2.10000e+01,-3.04859e+00,-2.51269e+01, -7.96007e-10,-2.50486e+01,-2.12693e+00, -2.40000e+01,-4.85874e-02,-1.26928e-01});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input}, {}, {1});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test3) {

    auto input = NDArrayFactory::create<double>('c', {3, 3, 3}, {-1, 1, -2, 2, -3, 3, -4, 4, -5,5 ,-6,6, -7,7, -8,8, -9,9, -10,10, -11,11, -12,12, -13,13, 14});
    auto expOutput = NDArrayFactory::create<double>('c', {3, 3, 3}, {-2.16985e+00,-1.69846e-01,-3.16985e+00, -1.31507e+00,-6.31507e+00,-3.15072e-01, -8.00046e+00,-4.58767e-04,-9.00046e+00, -1.31327e+00,-1.23133e+01,-3.13266e-01, -1.40000e+01,-1.13743e-06,-1.50000e+01, -1.31326e+00,-1.83133e+01,-3.13262e-01, -2.00000e+01,-2.81941e-09,-2.10000e+01, -1.31326e+00,-2.43133e+01,-3.13262e-01, -2.73133e+01,-1.31326e+00,-3.13262e-01});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input}, {}, {2});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));



}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test5) {

    auto input = NDArrayFactory::create<double>('c', {3, 3}, {-1, 1, -2, 2, -3, 3, -4, 4, 5});
    auto expOutput = NDArrayFactory::create<double>('c', {3, 3}, {-2.16985, -0.16985, -3.16985, -1.31507, -6.31507, -0.31507, -9.31335, -1.31335, -0.31335});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test6) {

    auto input = NDArrayFactory::create<double>('c', {3, 3}, {-1, 1, -2, 2, -3, 3, -4, 4, 5});
    auto expOutput = NDArrayFactory::create<double>('c', {3, 3}, {-3.05095,-3.04946,-7.12773, -0.05095,-7.04946,-2.12773, -6.05095,-0.04946,-0.12773});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input}, {}, {0});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test7) {

    auto input = NDArrayFactory::create<double>('c', {1, 5}, {-1, 1, -2, 2, 3});
    auto expOutput = NDArrayFactory::create<double>('c', {1, 5}, {-4.42414, -2.42414, -5.42414, -1.42414, -0.42414});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test8) {

    auto input = NDArrayFactory::create<double>('c', {1, 5}, {-1, 1, -2, 2, 3});
    auto expOutput = NDArrayFactory::create<double>('c', {1, 5}, {0, 0, 0, 0, 0});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input}, {}, {0});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test9) {

    auto input = NDArrayFactory::create<double>('c', {5, 1}, {-1, 1, -2, 2, 3});
    auto expOutput = NDArrayFactory::create<double>('c', {5, 1}, {0, 0, 0, 0, 0});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test10) {

    auto input = NDArrayFactory::create<double>('c', {5, 1}, {-1, 1, -2, 2, 3});
    auto expOutput = NDArrayFactory::create<double>('c', {5, 1}, {-4.42414, -2.42414, -5.42414, -1.42414, -0.42414});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input}, {}, {0});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test11) {

    auto input = NDArrayFactory::create<double>('c', {5}, {-1, 1, -2, 2, 3});
    auto expOutput = NDArrayFactory::create<double>('c', {5}, {-4.42414, -2.42414, -5.42414, -1.42414, -0.42414});

    sd::ops::log_softmax op;
    auto  results = op.evaluate({&input});
    auto z = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(expOutput.isSameShape(z));
    ASSERT_TRUE(expOutput.equalsTo(z));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_test12) {

    auto input = NDArrayFactory::create<double>('c', {1, 4}, {0.1869,   -1.4918,   -0.6497,   -0.8864});
    auto expOutput = NDArrayFactory::create<double>('c', {1, 4}, {-0.6738,   -2.3525,   -1.5104,   -1.7472});

    for (int i = 0; i < 10; ++i)
    {
        sd::ops::log_softmax op;
        auto  results = op.evaluate({&input});
        auto z = results.at(0);

        ASSERT_EQ(Status::OK(), results.status());
        ASSERT_TRUE(expOutput.isSameShape(z));
        ASSERT_TRUE(expOutput.equalsTo(z, 1e-4));


    }
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_bp_test1) {

    auto input   = NDArrayFactory::create<double>('c', {2, 2}, {1,2,3,4});
    auto epsilon = NDArrayFactory::create<double>('c', {2, 2}, {0.1, 0.2, 0.3, 0.4});
    auto exp = NDArrayFactory::create<double>('c', {2, 2}, {-0.07311,0.02689, -0.07311,0.02689});

    sd::ops::log_softmax_bp op;
    auto  results = op.evaluate({&input, &epsilon});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, log_softmax_bp_test2) {

    auto input   = NDArrayFactory::create<double>('c', {2, 2}, {1,2,3,4});
    auto epsilon = NDArrayFactory::create<double>('c', {2, 2}, {0.1, 0.2, 0.3, 0.4});
    auto exp = NDArrayFactory::create<double>('c', {2, 2}, {-0.17616, -0.17616, 0.02384,  0.02384});

    sd::ops::log_softmax_bp op;
    auto  results = op.evaluate({&input, &epsilon}, {}, {0});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, ELU_1) {

    auto input   = NDArrayFactory::create<double>('c', {2, 2, 2}, { -1.,  2. , 1.5, -1.4, 1.,   2.,  2.,   1.});
    auto exp     = NDArrayFactory::create<double>('c', {2, 2, 2}, { -0.63212055,  2. , 1.5, -0.753403, 1.,   2.,  2.,   1.});
    auto res     = NDArrayFactory::create<double>('c', {2, 2, 2});

    input.applyScalar(sd::scalar::ELU, 1.f, res);

    ASSERT_TRUE(res.equalsTo(&exp));
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, L2_Loss_1) {

    auto input   = NDArrayFactory::create<double>('c', {2, 2, 2}, { -1.,  2. , 1.5, -1.4, 1.,   2.,  2.,   1.});
    double exp(9.605);

    sd::ops::l2_loss op;
    auto results = op.evaluate({&input}, {}, {});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(output->isScalar());

    ASSERT_EQ(output->e<double>(0), exp);


}

TEST_F(DeclarableOpsTests5, L2_Loss_2) {
    auto x = NDArrayFactory::create<double>(0.7787855863571167);
    auto e = NDArrayFactory::create<double>(0.303254);

    sd::ops::l2_loss op;
    auto results = op.evaluate({&x}, {}, {});
    ASSERT_EQ(Status::OK(), results.status());

    auto z = results.at(0);

    ASSERT_EQ(e, *z);


}

TEST_F(DeclarableOpsTests5, L2_Loss_3) {
    auto x = NDArrayFactory::create<double>(0.7787855863571167);
    auto e = NDArrayFactory::create<double>(0.303254);
    auto z = NDArrayFactory::create<double>(0.0);

    sd::ops::l2_loss op;
    auto status = op.execute({&x}, {&z} , {}, {}, {});
    ASSERT_EQ(Status::OK(), status);

    ASSERT_EQ(e, z);
}

//////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, LogPoissonLoss_1) {
    auto weights = NDArrayFactory::create<double>('c', {1, 1}, {1});

    auto input   = NDArrayFactory::create<double>('c', {2, 2, 2}, { -1.,  2. , 1.5, -1.4, 1.,   2.,  2.,   1.});
    auto targets = NDArrayFactory::create<double>('c', {2, 2, 2}, {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0});

    auto exp = NDArrayFactory::create<double>('c', {2, 2, 2}, {1.3678794, 5.389056, 2.981689, 1.6465969, 1.7182817, 5.389056, 5.389056, 1.7182817});

    sd::ops::log_poisson_loss op;
    auto results = op.evaluate({&input, &weights, &targets}, {}, {0});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, LogPoissonLoss_2) {

    auto weights = NDArrayFactory::create<double>('c', {1, 1}, {1});

    auto input   = NDArrayFactory::create<double>('c', {2, 2, 2}, { -1.,  2. , 1.5, -1.4, 1.,   2.,  2.,   1.});
    auto targets = NDArrayFactory::create<double>('c', {2, 2, 2}, {2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0});

    auto exp = NDArrayFactory::create<double>('c', {2, 2, 2}, {3.0196857, 4.0408626, 2.1334953, 3.6984034, 1.3700882, 4.0408626, 4.0408626, 1.3700882});

    sd::ops::log_poisson_loss op;
    auto results = op.evaluate({&input, &weights, &targets}, {}, {0, 1});
    auto output = results.at(0);

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_TRUE(exp.isSameShape(output));
    ASSERT_TRUE(exp.equalsTo(output));


}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, NormalizeMoments_1) {

    auto means   = NDArrayFactory::create<double>('c', {2, 3, 4}, { 11.,   3.,  14.,   5.,
                                               6.,   9.,  3.5,   7.,
                                              21.,   3.,  14.,  15.,
                                               6.,   9.,  3.5,   7.,
                                              11.,  13.,  14.,   5.,
                                              16.,   9., 13.5,   7.});

    auto deviance = NDArrayFactory::create<double>('c', {2, 3, 4}, { 21.,  13.,  24.,  15.,
                                               16.,  19., 13.5,  17.,
                                               31.,  13.,  24.,  25.,
                                               16.,  19., 13.5,  17.,
                                               21.,  23.,  24.,  15.,
                                               26.,  19., 23.5,  17.});

    auto counts = NDArrayFactory::create<double>(2.0);

    auto expMeans = NDArrayFactory::create<double>('c', {2, 3, 4}, {
                                                 5.5,   1.5,     7.,  2.5,
                                                  3.,   4.5,   1.75,  3.5,
                                                10.5,   1.5,     7.,  7.5,
                                                  3.,   4.5,   1.75,  3.5,
                                                 5.5,   6.5,     7.,  2.5,
                                                  8.,   4.5,   6.75,  3.5});

    auto expDeviance = NDArrayFactory::create<double>('c', {2, 3, 4}, {
                                                -19.75,     4.25,       -37.,   1.25,
                                                   -1.,   -10.75,     3.6875,  -3.75,
                                                -94.75,     4.25,       -37.,  -43.75,
                                                   -1.,   -10.75,     3.6875,  -3.75,
                                                -19.75,   -30.75,       -37.,   1.25,
                                                  -51.,   -10.75,   -33.8125,  -3.75});

    sd::ops::normalize_moments op;
    auto results = op.evaluate({&counts, &means, &deviance}, {0.0}, {});

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_EQ(results.size(), 2);

    auto outputMeans = results.at(0);
    auto outputDeviance = results.at(1);

    ASSERT_TRUE(expMeans.isSameShape(outputMeans));
    ASSERT_TRUE(expMeans.equalsTo(outputMeans));
    ASSERT_TRUE(expMeans.isSameShape(outputDeviance));
    ASSERT_TRUE(expDeviance.equalsTo(outputDeviance));


}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, NormalizeMoments_2) {

    auto means   = NDArrayFactory::create<double>('c', {3, 2, 4}, { 11.,   3.,  14.,   5.,
                                               6.,   9.,  3.5,   7.,
                                              21.,   3.,  14.,  15.,
                                               6.,   9.,  3.5,   7.,
                                              11.,  13.,  14.,   5.,
                                              16.,   9., 13.5,   7.});

    auto deviance = NDArrayFactory::create<double>('c', {3, 2, 4}, { 21.,  13.,  24.,  15.,
                                               16.,  19., 13.5,  17.,
                                               31.,  13.,  24.,  25.,
                                               16.,  19., 13.5,  17.,
                                               21.,  23.,  24.,  15.,
                                               26.,  19., 23.5,  17.});

    auto counts = NDArrayFactory::create<double>(12.0);

    auto expMeans = NDArrayFactory::create<double>('c', {3, 2, 4}, { 0.9166667,     0.25,  1.1666667, 0.4166667,
                                                     0.5,     0.75,  0.2916667, 0.5833334,
                                                    1.75,     0.25,  1.1666667,      1.25,
                                                     0.5,     0.75,  0.2916667, 0.5833334,
                                               0.9166667, 1.0833334, 1.1666667, 0.4166667,
                                               1.3333334,      0.75,     1.125, 0.5833334});

    auto expDeviance = NDArrayFactory::create<double>('c', {3, 2, 4}, {
                                                 0.9097222,  1.0208334,  0.6388887,  1.0763888,
                                                 1.0833334,  1.0208334,  1.0399306,   1.076389,
                                                -0.4791665,  1.0208334,  0.6388887,  0.5208335,
                                                 1.0833334,  1.0208334,  1.0399306,   1.076389,
                                                 0.9097222,  0.7430556,  0.6388887,  1.0763888,
                                                0.38888884,  1.0208334,  0.6927084,   1.076389});

    sd::ops::normalize_moments op;
    auto results = op.evaluate({&counts, &means, &deviance}, {0.0}, {});

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_EQ(results.size(), 2);

    auto outputMeans = results.at(0);
    auto outputDeviance = results.at(1);

    ASSERT_TRUE(expMeans.isSameShape(outputMeans));
    ASSERT_TRUE(expMeans.equalsTo(outputMeans));
    ASSERT_TRUE(expMeans.isSameShape(outputDeviance));
    ASSERT_TRUE(expDeviance.equalsTo(outputDeviance));


}

////////////////////////////////////////////////////////////////////////////////
TEST_F(DeclarableOpsTests5, NormalizeMoments_3) {

    auto means   = NDArrayFactory::create<double>('c', {3, 2, 4}, { 11.,   3.,  14.,   5.,
                                               6.,   9.,  3.5,   7.,
                                              21.,   3.,  14.,  15.,
                                               6.,   9.,  3.5,   7.,
                                              11.,  13.,  14.,   5.,
                                              16.,   9., 13.5,   7.});

    auto deviance = NDArrayFactory::create<double>('c', {3, 2, 4}, { 21.,  13.,  24.,  15.,
                                               16.,  19., 13.5,  17.,
                                               31.,  13.,  24.,  25.,
                                               16.,  19., 13.5,  17.,
                                               21.,  23.,  24.,  15.,
                                               26.,  19., 23.5,  17.});

    auto counts = NDArrayFactory::create<double>(12.0);
    double shift = 10.0;
    auto expMeans = NDArrayFactory::create<double>('c', {3, 2, 4}, { 10.9166667,     10.25,  11.1666667, 10.4166667,
                                                     10.5,     10.75,  10.2916667, 10.5833334,
                                                    11.75,     10.25,  11.1666667,      11.25,
                                                     10.5,     10.75,  10.2916667, 10.5833334,
                                               10.9166667, 11.0833334, 11.1666667, 10.4166667,
                                               11.3333334,      10.75,     11.125, 10.5833334});

    auto expDeviance = NDArrayFactory::create<double>('c', {3, 2, 4}, {
                                                 0.9097222,  1.0208334,  0.6388887,  1.0763888,
                                                 1.0833334,  1.0208334,  1.0399306,   1.076389,
                                                -0.4791665,  1.0208334,  0.6388887,  0.5208335,
                                                 1.0833334,  1.0208334,  1.0399306,   1.076389,
                                                 0.9097222,  0.7430556,  0.6388887,  1.0763888,
                                                0.38888884,  1.0208334,  0.6927084,   1.076389});

    sd::ops::normalize_moments op;
    auto results = op.evaluate({&counts, &means, &deviance}, {shift}, {});

    ASSERT_EQ(Status::OK(), results.status());
    ASSERT_EQ(results.size(), 2);

    auto outputMeans = results.at(0);
    auto outputDeviance = results.at(1);

    ASSERT_TRUE(expMeans.isSameShape(outputMeans));
    ASSERT_TRUE(expMeans.equalsTo(outputMeans));
    ASSERT_TRUE(expMeans.isSameShape(outputDeviance));
    ASSERT_TRUE(expDeviance.equalsTo(outputDeviance));


}