• Home
• org.nd4j
• nd4j-cuda-11.4
• 1.0.0-M2.1
• source code
• Nd4jCuda.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.nd4j.linalg.jcublas.bindings.Nd4jCuda Maven / Gradle / Ivy

// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE

package org.nd4j.linalg.jcublas.bindings;

import java.nio.*;
import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

public class Nd4jCuda extends org.nd4j.presets.cuda.Nd4jCudaHelper {
    static { Loader.load(); }

@Name("std::vector >") public static class IntVectorVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public IntVectorVector(Pointer p) { super(p); }
    public IntVectorVector(int[] ... array) { this(array.length); put(array); }
    public IntVectorVector()       { allocate();  }
    public IntVectorVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator =") @ByRef IntVectorVector put(@ByRef IntVectorVector x);

    public boolean empty() { return size() == 0; }
    public native long size();
    public void clear() { resize(0); }
    public native void resize(@Cast("size_t") long n);
    public boolean empty(@Cast("size_t") long i) { return size(i) == 0; }
    public native @Index(function = "at") long size(@Cast("size_t") long i);
    public void clear(@Cast("size_t") long i) { resize(i, 0); }
    public native @Index(function = "at") void resize(@Cast("size_t") long i, @Cast("size_t") long n);

    @Index(function = "at") public native int get(@Cast("size_t") long i, @Cast("size_t") long j);
    public native IntVectorVector put(@Cast("size_t") long i, @Cast("size_t") long j, int value);

    public int[][] get() {
        int[][] array = new int[size() < Integer.MAX_VALUE ? (int)size() : Integer.MAX_VALUE][];
        for (int i = 0; i < array.length; i++) {
            array[i] = new int[size(i) < Integer.MAX_VALUE ? (int)size(i) : Integer.MAX_VALUE];
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = get(i, j);
            }
        }
        return array;
    }
    @Override public String toString() {
        return java.util.Arrays.deepToString(get());
    }

    public IntVectorVector put(int[] ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            if (size(i) != array[i].length) { resize(i, array[i].length); }
            for (int j = 0; j < array[i].length; j++) {
                put(i, j, array[i][j]);
            }
        }
        return this;
    }
}

@Name("std::vector >") public static class LongVectorVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public LongVectorVector(Pointer p) { super(p); }
    public LongVectorVector(long[] ... array) { this(array.length); put(array); }
    public LongVectorVector()       { allocate();  }
    public LongVectorVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator =") @ByRef LongVectorVector put(@ByRef LongVectorVector x);

    public boolean empty() { return size() == 0; }
    public native long size();
    public void clear() { resize(0); }
    public native void resize(@Cast("size_t") long n);
    public boolean empty(@Cast("size_t") long i) { return size(i) == 0; }
    public native @Index(function = "at") long size(@Cast("size_t") long i);
    public void clear(@Cast("size_t") long i) { resize(i, 0); }
    public native @Index(function = "at") void resize(@Cast("size_t") long i, @Cast("size_t") long n);

    @Index(function = "at") public native @Cast("sd::LongType") long get(@Cast("size_t") long i, @Cast("size_t") long j);
    public native LongVectorVector put(@Cast("size_t") long i, @Cast("size_t") long j, long value);

    public long[][] get() {
        long[][] array = new long[size() < Integer.MAX_VALUE ? (int)size() : Integer.MAX_VALUE][];
        for (int i = 0; i < array.length; i++) {
            array[i] = new long[size(i) < Integer.MAX_VALUE ? (int)size(i) : Integer.MAX_VALUE];
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = get(i, j);
            }
        }
        return array;
    }
    @Override public String toString() {
        return java.util.Arrays.deepToString(get());
    }

    public LongVectorVector put(long[] ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            if (size(i) != array[i].length) { resize(i, array[i].length); }
            for (int j = 0; j < array[i].length; j++) {
                put(i, j, array[i][j]);
            }
        }
        return this;
    }
}

@Name("std::vector") public static class NDArrayVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public NDArrayVector(Pointer p) { super(p); }
    public NDArrayVector(NDArray value) { this(1); put(0, value); }
    public NDArrayVector(NDArray ... array) { this(array.length); put(array); }
    public NDArrayVector()       { allocate();  }
    public NDArrayVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator =") @ByRef NDArrayVector put(@ByRef NDArrayVector x);

    public boolean empty() { return size() == 0; }
    public native long size();
    public void clear() { resize(0); }
    public native void resize(@Cast("size_t") long n);

    @Index(function = "at") public native NDArray get(@Cast("size_t") long i);
    public native NDArrayVector put(@Cast("size_t") long i, NDArray value);

    public native @ByVal Iterator insert(@ByVal Iterator pos, NDArray value);
    public native @ByVal Iterator erase(@ByVal Iterator pos);
    public native @ByVal Iterator begin();
    public native @ByVal Iterator end();
    @NoOffset @Name("iterator") public static class Iterator extends Pointer {
        public Iterator(Pointer p) { super(p); }
        public Iterator() { }

        public native @Name("operator ++") @ByRef Iterator increment();
        public native @Name("operator ==") boolean equals(@ByRef Iterator it);
        public native @Name("operator *") @Const NDArray get();
    }

    public NDArray[] get() {
        NDArray[] array = new NDArray[size() < Integer.MAX_VALUE ? (int)size() : Integer.MAX_VALUE];
        for (int i = 0; i < array.length; i++) {
            array[i] = get(i);
        }
        return array;
    }
    @Override public String toString() {
        return java.util.Arrays.toString(get());
    }

    public NDArray pop_back() {
        long size = size();
        NDArray value = get(size - 1);
        resize(size - 1);
        return value;
    }
    public NDArrayVector push_back(NDArray value) {
        long size = size();
        resize(size + 1);
        return put(size, value);
    }
    public NDArrayVector put(NDArray value) {
        if (size() != 1) { resize(1); }
        return put(0, value);
    }
    public NDArrayVector put(NDArray ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector") public static class ConstNDArrayVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ConstNDArrayVector(Pointer p) { super(p); }
    public ConstNDArrayVector(NDArray value) { this(1); put(0, value); }
    public ConstNDArrayVector(NDArray ... array) { this(array.length); put(array); }
    public ConstNDArrayVector()       { allocate();  }
    public ConstNDArrayVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator =") @ByRef ConstNDArrayVector put(@ByRef ConstNDArrayVector x);

    public boolean empty() { return size() == 0; }
    public native long size();
    public void clear() { resize(0); }
    public native void resize(@Cast("size_t") long n);

    @Index(function = "at") public native @Const NDArray get(@Cast("size_t") long i);
    public native ConstNDArrayVector put(@Cast("size_t") long i, NDArray value);

    public native @ByVal Iterator insert(@ByVal Iterator pos, @Const NDArray value);
    public native @ByVal Iterator erase(@ByVal Iterator pos);
    public native @ByVal Iterator begin();
    public native @ByVal Iterator end();
    @NoOffset @Name("iterator") public static class Iterator extends Pointer {
        public Iterator(Pointer p) { super(p); }
        public Iterator() { }

        public native @Name("operator ++") @ByRef Iterator increment();
        public native @Name("operator ==") boolean equals(@ByRef Iterator it);
        public native @Name("operator *") @Const NDArray get();
    }

    public NDArray[] get() {
        NDArray[] array = new NDArray[size() < Integer.MAX_VALUE ? (int)size() : Integer.MAX_VALUE];
        for (int i = 0; i < array.length; i++) {
            array[i] = get(i);
        }
        return array;
    }
    @Override public String toString() {
        return java.util.Arrays.toString(get());
    }

    public NDArray pop_back() {
        long size = size();
        NDArray value = get(size - 1);
        resize(size - 1);
        return value;
    }
    public ConstNDArrayVector push_back(NDArray value) {
        long size = size();
        resize(size + 1);
        return put(size, value);
    }
    public ConstNDArrayVector put(NDArray value) {
        if (size() != 1) { resize(1); }
        return put(0, value);
    }
    public ConstNDArrayVector put(NDArray ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@NoOffset @Name("std::pair") public static class IntIntPair extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public IntIntPair(Pointer p) { super(p); }
    public IntIntPair(int firstValue, int secondValue) { this(); put(firstValue, secondValue); }
    public IntIntPair()       { allocate();  }
    private native void allocate();
    public native @Name("operator =") @ByRef IntIntPair put(@ByRef IntIntPair x);


    @MemberGetter public native int first(); public native IntIntPair first(int first);
    @MemberGetter public native int second();  public native IntIntPair second(int second);

    public IntIntPair put(int firstValue, int secondValue) {
        first(firstValue);
        second(secondValue);
        return this;
    }
}

// Parsed from generated/include_ops.h

// #ifndef SD_DEFINITIONS_GEN_H_
// #define SD_DEFINITIONS_GEN_H_
// #define SD_ALL_OPS 1

// #endif


// Parsed from array/DataType.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef ND4J_DATATYPE_H
// #define ND4J_DATATYPE_H
/** enum sd::DataType */
public static final int
  INHERIT = 0,
  BOOL = 1,
  FLOAT8 = 2,
  HALF = 3,
  HALF2 = 4,
  FLOAT32 = 5,
  DOUBLE = 6,
  INT8 = 7,
  INT16 = 8,
  INT32 = 9,
  INT64 = 10,
  UINT8 = 11,
  UINT16 = 12,
  UINT32 = 13,
  UINT64 = 14,
  QINT8 = 15,
  QINT16 = 16,
  BFLOAT16 = 17,
  UTF8 = 50,
  UTF16 = 51,
  UTF32 = 52,
  ANY = 100,
  AUTO = 200;


// #endif


// Parsed from array/DataBuffer.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
// @author Yurii Shyrma ([email protected])
//

// #ifndef DEV_TESTS_DATABUFFER_H
// #define DEV_TESTS_DATABUFFER_H

// #include 
// #include 
// #include 
// #include 
// #include 

// #include 

@Namespace("sd") @NoOffset public static class DataBuffer extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DataBuffer(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public DataBuffer(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public DataBuffer position(long position) {
        return (DataBuffer)super.position(position);
    }
    @Override public DataBuffer getPointer(long i) {
        return new DataBuffer((Pointer)this).offsetAddress(i);
    }

  public DataBuffer(Pointer primary, Pointer special, @Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType,
               @Cast("const bool") boolean isOwnerPrimary/*=false*/, @Cast("const bool") boolean isOwnerSpecial/*=false*/,
               Workspace workspace/*=nullptr*/) { super((Pointer)null); allocate(primary, special, lenInBytes, dataType, isOwnerPrimary, isOwnerSpecial, workspace); }
  private native void allocate(Pointer primary, Pointer special, @Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType,
               @Cast("const bool") boolean isOwnerPrimary/*=false*/, @Cast("const bool") boolean isOwnerSpecial/*=false*/,
               Workspace workspace/*=nullptr*/);
  public DataBuffer(Pointer primary, Pointer special, @Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType) { super((Pointer)null); allocate(primary, special, lenInBytes, dataType); }
  private native void allocate(Pointer primary, Pointer special, @Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType);

  public DataBuffer(Pointer primary, @Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType, @Cast("const bool") boolean isOwnerPrimary/*=false*/,
               Workspace workspace/*=nullptr*/) { super((Pointer)null); allocate(primary, lenInBytes, dataType, isOwnerPrimary, workspace); }
  private native void allocate(Pointer primary, @Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType, @Cast("const bool") boolean isOwnerPrimary/*=false*/,
               Workspace workspace/*=nullptr*/);
  public DataBuffer(Pointer primary, @Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType) { super((Pointer)null); allocate(primary, lenInBytes, dataType); }
  private native void allocate(Pointer primary, @Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType);

  public DataBuffer(@Const Pointer hostBuffer,
               @Cast("const sd::DataType") int dataType, @Cast("const size_t") long lenInBytes, Workspace workspace/*=nullptr*/) { super((Pointer)null); allocate(hostBuffer, dataType, lenInBytes, workspace); }
  private native void allocate(@Const Pointer hostBuffer,
               @Cast("const sd::DataType") int dataType, @Cast("const size_t") long lenInBytes, Workspace workspace/*=nullptr*/);
  public DataBuffer(@Const Pointer hostBuffer,
               @Cast("const sd::DataType") int dataType, @Cast("const size_t") long lenInBytes) { super((Pointer)null); allocate(hostBuffer, dataType, lenInBytes); }
  private native void allocate(@Const Pointer hostBuffer,
               @Cast("const sd::DataType") int dataType, @Cast("const size_t") long lenInBytes);

  public DataBuffer(@Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType, Workspace workspace/*=nullptr*/,
               @Cast("const bool") boolean allocBoth/*=false*/) { super((Pointer)null); allocate(lenInBytes, dataType, workspace, allocBoth); }
  private native void allocate(@Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType, Workspace workspace/*=nullptr*/,
               @Cast("const bool") boolean allocBoth/*=false*/);
  public DataBuffer(@Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType) { super((Pointer)null); allocate(lenInBytes, dataType); }
  private native void allocate(@Cast("const size_t") long lenInBytes, @Cast("const sd::DataType") int dataType);

  public DataBuffer(@Const @ByRef DataBuffer other) { super((Pointer)null); allocate(other); }
  private native void allocate(@Const @ByRef DataBuffer other);
  public DataBuffer() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native @ByRef @Name("operator =") DataBuffer put(@Const @ByRef DataBuffer other);

  public native @Cast("sd::DataType") int getDataType();
  public native void setDataType(@Cast("sd::DataType") int dataType);
  public native @Cast("size_t") long getLenInBytes();

  public native Pointer primary();
  public native Pointer special();

  public native void allocatePrimary();
  public native void allocateSpecial();

  public native void writePrimary();
  public native void writeSpecial();
  public native void readPrimary();
  public native void readSpecial();
  public native @Cast("bool") boolean isPrimaryActual();
  public native @Cast("bool") boolean isSpecialActual();

  public native void expand(@Cast("const uint64_t") long size);

  public native int deviceId();
  public native void setDeviceId(int deviceId);
  public native void migrate();

  public native void syncToPrimary(@Const LaunchContext context, @Cast("const bool") boolean forceSync/*=false*/);
  public native void syncToPrimary(@Const LaunchContext context);
  public native void syncToSpecial(@Cast("const bool") boolean forceSync/*=false*/);
  public native void syncToSpecial();

  public native void setToZeroBuffers(@Cast("const bool") boolean both/*=false*/);
  public native void setToZeroBuffers();

  public native void copyBufferFrom(@Const @ByRef DataBuffer other, @Cast("size_t") long sizeToCopyinBytes/*=0*/, @Cast("const sd::LongType") long offsetThis/*=0*/,
                        @Cast("const sd::LongType") long offsetOther/*=0*/);
  public native void copyBufferFrom(@Const @ByRef DataBuffer other);

  public static native void memcpy(@Const @ByRef DataBuffer dst, @Const @ByRef DataBuffer src);

  public native void setPrimaryBuffer(Pointer buffer, @Cast("size_t") long length);
  public native void setSpecialBuffer(Pointer buffer, @Cast("size_t") long length);
// #ifndef __JAVACPP_HACK__
// #endif

  public native void showBufferLimited();
  //for Debug purposes
  public native void showCounters(@Cast("char*") String msg1, @Cast("char*") String msg2);
  public native void showCounters(@Cast("char*") BytePointer msg1, @Cast("char*") BytePointer msg2);

  /**
   * This method deletes buffers, if we're owners
   */
  public native @Name("close") void _close();
}
///// IMLEMENTATION OF INLINE METHODS /////

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


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


  // namespace sd

// #endif  // DEV_TESTS_DATABUFFER_H


// Parsed from array/PointerDeallocator.h

/*
 *  ******************************************************************************
 *  *
 *  *
 *  * 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 [email protected]
//

// #ifndef SD_POINTERDEALLOCATOR_H_
// #define SD_POINTERDEALLOCATOR_H_

// #include 

  // namespace sd

// #endif  // SD_POINTERDEALLOCATOR_H_


// Parsed from array/PointerWrapper.h

/*
 *  ******************************************************************************
 *  *
 *  *
 *  * 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 [email protected]
//

// #ifndef SD_ARRAY_POINTER_H_
// #define SD_ARRAY_POINTER_H_

// #include 

// #include 
  // namespace sd

// #endif  // SD_ARRAY_POINTER_H_


// Parsed from array/ConstantDescriptor.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef DEV_TESTS_CONSTANTDESCRIPTOR_H
// #define DEV_TESTS_CONSTANTDESCRIPTOR_H

// #include 
// #include 
// #include 

// #include 
// #include 
@Namespace("sd") @NoOffset public static class ConstantDescriptor extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ConstantDescriptor(Pointer p) { super(p); }

  public ConstantDescriptor(DoublePointer values, int length) { super((Pointer)null); allocate(values, length); }
  private native void allocate(DoublePointer values, int length);
  public ConstantDescriptor(DoubleBuffer values, int length) { super((Pointer)null); allocate(values, length); }
  private native void allocate(DoubleBuffer values, int length);
  public ConstantDescriptor(double[] values, int length) { super((Pointer)null); allocate(values, length); }
  private native void allocate(double[] values, int length);
  public ConstantDescriptor(@Cast("const sd::LongType*") LongPointer values, int length) { super((Pointer)null); allocate(values, length); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer values, int length);
  public ConstantDescriptor(@Cast("const sd::LongType*") LongBuffer values, int length) { super((Pointer)null); allocate(values, length); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer values, int length);
  public ConstantDescriptor(@Cast("const sd::LongType*") long[] values, int length) { super((Pointer)null); allocate(values, length); }
  private native void allocate(@Cast("const sd::LongType*") long[] values, int length);

  public ConstantDescriptor(@Cast("sd::LongType*") @StdVector LongPointer values) { super((Pointer)null); allocate(values); }
  private native void allocate(@Cast("sd::LongType*") @StdVector LongPointer values);
  public ConstantDescriptor(@Cast("sd::LongType*") @StdVector LongBuffer values) { super((Pointer)null); allocate(values); }
  private native void allocate(@Cast("sd::LongType*") @StdVector LongBuffer values);
  public ConstantDescriptor(@Cast("sd::LongType*") @StdVector long[] values) { super((Pointer)null); allocate(values); }
  private native void allocate(@Cast("sd::LongType*") @StdVector long[] values);
  public ConstantDescriptor(@StdVector DoublePointer values) { super((Pointer)null); allocate(values); }
  private native void allocate(@StdVector DoublePointer values);
  public ConstantDescriptor(@StdVector DoubleBuffer values) { super((Pointer)null); allocate(values); }
  private native void allocate(@StdVector DoubleBuffer values);
  public ConstantDescriptor(@StdVector double[] values) { super((Pointer)null); allocate(values); }
  private native void allocate(@StdVector double[] values);

  // equal to operator
  public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef ConstantDescriptor other);

  // less than operator
  public native @Cast("bool") @Name("operator <") boolean lessThan(@Const @ByRef ConstantDescriptor other);

  public native @Cast("bool") boolean isInteger();
  public native @Cast("bool") boolean isFloat();

  public native @Cast("sd::LongType") long length();

  public native @Cast("sd::LongType*") @StdVector LongPointer integerValues();
  public native @StdVector DoublePointer floatValues();
}
  // namespace sd

// #ifndef __JAVACPP_HACK__

// #endif

// #endif  // DEV_TESTS_CONSTANTDESCRIPTOR_H


// Parsed from array/ConstantDataBuffer.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]

// #ifndef LIBND4J_CONSTANTDATABUFFER_H
// #define LIBND4J_CONSTANTDATABUFFER_H

// #include 
// #include 
// #include 

// #include 
@Namespace("sd") @NoOffset public static class ConstantDataBuffer extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ConstantDataBuffer(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ConstantDataBuffer(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ConstantDataBuffer position(long position) {
        return (ConstantDataBuffer)super.position(position);
    }
    @Override public ConstantDataBuffer getPointer(long i) {
        return new ConstantDataBuffer((Pointer)this).offsetAddress(i);
    }

  public ConstantDataBuffer(@Const @ByRef ConstantDataBuffer other) { super((Pointer)null); allocate(other); }
  private native void allocate(@Const @ByRef ConstantDataBuffer other);
  public ConstantDataBuffer() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native @Cast("uint8_t") byte sizeOf();
  public native @Cast("uint64_t") long length();

  public native Pointer primary();
  public native Pointer special();

  public native @ByRef @Name("operator =") ConstantDataBuffer put(@Const @ByRef ConstantDataBuffer other);
}
  // namespace sd

// #endif  // DEV_TESTS_CONSTANTDATABUFFER_H


// Parsed from array/ConstantShapeBuffer.h

/*
 *  ******************************************************************************
 *  *
 *  *
 *  * 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 [email protected]
//

// #ifndef SD_ARRAY_CONSTANTSHAPEBUFFER_H_
// #define SD_ARRAY_CONSTANTSHAPEBUFFER_H_

// #include 
// #include 

// #include 

@Namespace("sd") public static class ConstantShapeBuffer extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ConstantShapeBuffer(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ConstantShapeBuffer(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ConstantShapeBuffer position(long position) {
        return (ConstantShapeBuffer)super.position(position);
    }
    @Override public ConstantShapeBuffer getPointer(long i) {
        return new ConstantShapeBuffer((Pointer)this).offsetAddress(i);
    }

  public ConstantShapeBuffer() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native @Cast("const sd::LongType*") LongPointer primary();
  public native @Cast("const sd::LongType*") LongPointer special();
  public native @Cast("const sd::LongType*") LongPointer platform();
}

  // namespace sd

// #endif  // SD_ARRAY_CONSTANTSHAPEBUFFER_H_


// Parsed from array/ConstantOffsetsBuffer.h

/*
 *  ******************************************************************************
 *  *
 *  *
 *  * 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 [email protected]
//

// #ifndef SD_ARRAY_CONSTANTOFFSETSBUFFER_H_
// #define SD_ARRAY_CONSTANTOFFSETSBUFFER_H_

// #include 
// #include 

// #include 

@Namespace("sd") public static class ConstantOffsetsBuffer extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ConstantOffsetsBuffer(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ConstantOffsetsBuffer(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ConstantOffsetsBuffer position(long position) {
        return (ConstantOffsetsBuffer)super.position(position);
    }
    @Override public ConstantOffsetsBuffer getPointer(long i) {
        return new ConstantOffsetsBuffer((Pointer)this).offsetAddress(i);
    }

  public ConstantOffsetsBuffer() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native @Cast("const sd::LongType*") LongPointer primary();
  public native @Cast("const sd::LongType*") LongPointer special();
  public native @Cast("const sd::LongType*") LongPointer platform();
}

  // namespace sd

// #endif  // SD_ARRAY_CONSTANTOFFSETSBUFFER_H_


// Parsed from array/TadPack.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef DEV_TESTS_TADPACK_H
// #define DEV_TESTS_TADPACK_H

// #include 
// #include 
// #include 
@Namespace("sd") @NoOffset public static class TadPack extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public TadPack(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public TadPack(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public TadPack position(long position) {
        return (TadPack)super.position(position);
    }
    @Override public TadPack getPointer(long i) {
        return new TadPack((Pointer)this).offsetAddress(i);
    }

  public TadPack(@Const @ByRef ConstantShapeBuffer shapes, @Const @ByRef ConstantOffsetsBuffer offets, @Cast("sd::LongType") long numTads) { super((Pointer)null); allocate(shapes, offets, numTads); }
  private native void allocate(@Const @ByRef ConstantShapeBuffer shapes, @Const @ByRef ConstantOffsetsBuffer offets, @Cast("sd::LongType") long numTads);
  public TadPack() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native @Cast("const sd::LongType*") LongPointer primaryShapeInfo();
  public native @Cast("const sd::LongType*") LongPointer primaryOffsets();

  public native @Cast("const sd::LongType*") LongPointer specialShapeInfo();
  public native @Cast("const sd::LongType*") LongPointer specialOffsets();

  public native @Cast("sd::LongType") long numberOfTads();
  public native int shapeInfoLength();

  /**
   * These methods return either primary or special pointers depending on platform binaries were compiled for
   * @return
   */
  public native @Cast("const sd::LongType*") LongPointer platformShapeInfo();
  public native @Cast("const sd::LongType*") LongPointer platformOffsets();
}
  // namespace sd

// #endif  // DEV_TESTS_TADPACK_H


// Parsed from execution/ErrorReference.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef DEV_TESTS_ERRORREFERENCE_H
// #define DEV_TESTS_ERRORREFERENCE_H
// #include 

// #include 
@Namespace("sd") @NoOffset public static class ErrorReference extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ErrorReference(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ErrorReference(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ErrorReference position(long position) {
        return (ErrorReference)super.position(position);
    }
    @Override public ErrorReference getPointer(long i) {
        return new ErrorReference((Pointer)this).offsetAddress(i);
    }

  public ErrorReference() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native int errorCode();
  public native @Cast("char*") String errorMessage();

  public native void setErrorCode(int errorCode);
  public native void setErrorMessage(@StdString BytePointer message);
  public native void setErrorMessage(@StdString String message);
}
  // namespace sd

// #endif  // DEV_TESTS_ERRORREFERENCE_H


// Parsed from execution/Engine.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef SD_ENGINE_H
// #define SD_ENGINE_H
/** enum samediff::Engine */
public static final int
  ENGINE_CPU = 0,
  ENGINE_CUDA = 1;


// #endif  // SD_ENGINE_H


// Parsed from execution/ExecutionMode.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef SD_EXECUTIONMODE_H
// #define SD_EXECUTIONMODE_H
/** enum samediff::ExecutionMode */
public static final int
  MODE_UNDEFINED = 0,
  MODE_TRAINING = 1,
  MODE_INFERENCE = 2;


// #endif  // SD_EXECUTIONMODE_H


// Parsed from memory/MemoryType.h

//
// Created by raver119 on 07.05.19.
//

// #ifndef DEV_TESTS_MEMORYTYPE_H
// #define DEV_TESTS_MEMORYTYPE_H
/** enum sd::memory::MemoryType */
public static final int
  HOST = 0,
  DEVICE = 10;

  // namespace sd

// #endif  // DEV_TESTS_MEMORYTYPE_H


// Parsed from system/Environment.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 06.10.2017.
//

// #ifndef LIBND4J_ENVIRONMENT_H
// #define LIBND4J_ENVIRONMENT_H
// #include 
// #include 

// #include 
// #include 
// #include 
// #include 

// #ifndef __JAVACPP_HACK__
// #endif
@Namespace("sd") @NoOffset public static class Environment extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public Environment(Pointer p) { super(p); }

  /**
   * These 3 fields are mostly for CUDA/cuBLAS version tracking
   */
  public native int _blasMajorVersion(); public native Environment _blasMajorVersion(int setter);
  public native int _blasMinorVersion(); public native Environment _blasMinorVersion(int setter);
  public native int _blasPatchVersion(); public native Environment _blasPatchVersion(int setter);

  public static native @ByRef Environment getInstance();

  public native @Cast("bool") boolean isVerbose();
  public native void setVerbose(@Cast("bool") boolean reallyVerbose);
  public native @Cast("bool") boolean isDebug();
  public native @Cast("bool") boolean isProfiling();
  public native @Cast("bool") boolean isDetectingLeaks();
  public native @Cast("bool") boolean isDebugAndVerbose();
  public native void setDebug(@Cast("bool") boolean reallyDebug);
  public native void setProfiling(@Cast("bool") boolean reallyProfile);
  public native void setLeaksDetector(@Cast("bool") boolean reallyDetect);
  public native @Cast("bool") boolean helpersAllowed();
  public native void allowHelpers(@Cast("bool") boolean reallyAllow);

  public native @Cast("bool") boolean blasFallback();

  public native int tadThreshold();
  public native void setTadThreshold(int threshold);

  public native int elementwiseThreshold();
  public native void setElementwiseThreshold(int threshold);

  public native int maxThreads();
  public native void setMaxThreads(int max);

  public native int maxMasterThreads();
  public native void setMaxMasterThreads(int max);

  /*
   * Legacy memory limits API, still used in new API as simplified version
   */
  public native void setMaxPrimaryMemory(@Cast("uint64_t") long maxBytes);
  public native void setMaxSpecialyMemory(@Cast("uint64_t") long maxBytes);
  public native void setMaxDeviceMemory(@Cast("uint64_t") long maxBytes);

  public native @Cast("uint64_t") long maxPrimaryMemory();
  public native @Cast("uint64_t") long maxSpecialMemory();
  ////////////////////////

  /*
   * Methods for memory limits/counters
   */
  public native void setGroupLimit(int group, @Cast("sd::LongType") long numBytes);
  public native void setDeviceLimit(int deviceId, @Cast("sd::LongType") long numBytes);

  public native @Cast("sd::LongType") long getGroupLimit(int group);
  public native @Cast("sd::LongType") long getDeviceLimit(int deviceId);

  public native @Cast("sd::LongType") long getGroupCounter(int group);
  public native @Cast("sd::LongType") long getDeviceCounter(int deviceId);
  ////////////////////////

  public native @Cast("bool") boolean isUseONEDNN();
  public native void setUseONEDNN(@Cast("bool") boolean useMKLDNN);

  public native @Cast("sd::DataType") int defaultFloatDataType();
  public native void setDefaultFloatDataType(@Cast("sd::DataType") int dtype);

  public native @Cast("bool") boolean precisionBoostAllowed();
  public native void allowPrecisionBoost(@Cast("bool") boolean reallyAllow);

  public native @Cast("bool") boolean isExperimentalBuild();

  public native @Cast("bool") boolean isCPU();

  public native int blasMajorVersion();
  public native int blasMinorVersion();
  public native int blasPatchVersion();

  public native @StdVector Pair capabilities();

  public native @Cast("char*") String getVedaDeviceDir();

  public native void setVedaDeviceDir(@StdString BytePointer dir);
  public native void setVedaDeviceDir(@StdString String dir);
}
  // namespace sd

// #endif  // LIBND4J_ENVIRONMENT_H


// Parsed from types/utf8string.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef DEV_TESTS_UTF8STRING_H
// #define DEV_TESTS_UTF8STRING_H
// #include 
// #include 
@Namespace("sd") @NoOffset public static class utf8string extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public utf8string(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public utf8string(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public utf8string position(long position) {
        return (utf8string)super.position(position);
    }
    @Override public utf8string getPointer(long i) {
        return new utf8string((Pointer)this).offsetAddress(i);
    }

  public native @Cast("char*") BytePointer _buffer(); public native utf8string _buffer(BytePointer setter);
  public native @Cast("unsigned int") int _length(); public native utf8string _length(int setter);

  public utf8string() { super((Pointer)null); allocate(); }
  private native void allocate();

  public utf8string(@Cast("char*") String string, int length) { super((Pointer)null); allocate(string, length); }
  private native void allocate(@Cast("char*") String string, int length);
  public utf8string(@Cast("char*") BytePointer string, int length) { super((Pointer)null); allocate(string, length); }
  private native void allocate(@Cast("char*") BytePointer string, int length);
  public utf8string(@StdString BytePointer string) { super((Pointer)null); allocate(string); }
  private native void allocate(@StdString BytePointer string);
  public utf8string(@StdString String string) { super((Pointer)null); allocate(string); }
  private native void allocate(@StdString String string);
  public utf8string(@Const @ByRef utf8string other) { super((Pointer)null); allocate(other); }
  private native void allocate(@Const @ByRef utf8string other);
  public native @ByRef @Name("operator =") utf8string put(@Const @ByRef utf8string other);
}
  // namespace sd

// #endif  // DEV_TESTS_UTF8STRING_H


// Parsed from legacy/NativeOps.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by agibsonccc on 2/21/16.
//

// #ifndef NATIVEOPERATIONS_NATIVEOPS_H
// #define NATIVEOPERATIONS_NATIVEOPS_H

/*
#ifndef thread_local
# if __STDC_VERSION__ >= 201112 && !defined __STDC_NO_THREADS__
#  define thread_local _Thread_local
# elif defined _WIN32 && ( \
       defined _MSC_VER || \
       defined __ICL || \
       defined __DMC__ || \
       defined __BORLANDC__ )
#  define thread_local __declspec(thread)
// note that ICC (linux) and Clang are covered by __GNUC__
# elif defined __GNUC__ || \
       defined __SUNPRO_C || \
       defined __xlC__
#  define thread_local __thread
# else
#  error "Cannot define thread_local"
# endif
#endif
*/

// #include 
// #include 

/*
int tad_threshold = 1;
int element_threshold = 32;

bool debug = false;
bool verbose = false;
*/
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 

/**
 * This function returns last error code stored,
 * @return non-zero if something bad happened
 */
public native int lastErrorCode();

/**
 * This function returns last error message, if last error code > 0
 * @return
 */
public native @Cast("char*") String lastErrorMessage();

/**
 *
 * @param p
 * @param len
 */
public native void tryPointer(@Cast("sd::Pointer") Pointer extra, @Cast("sd::Pointer") Pointer p, int len);

/**
 *
 * @param num
 */
public native void setElementThreshold(int num);

/**
 *
 * @param num
 */
public native void setTADThreshold(int num);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParams
 */
public native void execIndexReduceScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                         @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                         Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                         @Cast("const sd::LongType*") LongPointer dZShapeInfo);
public native void execIndexReduceScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                         @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                         Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                         @Cast("const sd::LongType*") LongBuffer dZShapeInfo);
public native void execIndexReduceScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                         @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                         Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                         @Cast("const sd::LongType*") long[] dZShapeInfo);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParams
 * @param result
 * @param resultShapeInfoBuffer
 * @param dimension
 * @param dimensionLength
 */
public native void execIndexReduce(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") LongPointer hDimensionShape, @Cast("const sd::LongType*") LongPointer dDimensionShape);
public native void execIndexReduce(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") LongBuffer hDimensionShape, @Cast("const sd::LongType*") LongBuffer dDimensionShape);
public native void execIndexReduce(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                   @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") long[] hDimensionShape, @Cast("const sd::LongType*") long[] dDimensionShape);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param y
 * @param yShapeInfo
 * @param result
 * @param resultShapeInfo
 * @param dimension
 * @param dimensionLength
 */
public native void execBroadcast(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                 @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeInfo,
                                 @Cast("const sd::LongType*") LongPointer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                 @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") LongPointer hDimensionShape,
                                 @Cast("const sd::LongType*") LongPointer dDimensionShape);
public native void execBroadcast(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                 @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeInfo,
                                 @Cast("const sd::LongType*") LongBuffer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                 @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") LongBuffer hDimensionShape,
                                 @Cast("const sd::LongType*") LongBuffer dDimensionShape);
public native void execBroadcast(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                 @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeInfo,
                                 @Cast("const sd::LongType*") long[] dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                 @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") long[] hDimensionShape,
                                 @Cast("const sd::LongType*") long[] dDimensionShape);

public native void execBroadcastBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeInfo,
                                     @Cast("const sd::LongType*") LongPointer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                     @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo,
                                     Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                     @Cast("const sd::LongType*") LongPointer hDimensionShape, @Cast("const sd::LongType*") LongPointer dDimensionShape);
public native void execBroadcastBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeInfo,
                                     @Cast("const sd::LongType*") LongBuffer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                     @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo,
                                     Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                     @Cast("const sd::LongType*") LongBuffer hDimensionShape, @Cast("const sd::LongType*") LongBuffer dDimensionShape);
public native void execBroadcastBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeInfo,
                                     @Cast("const sd::LongType*") long[] dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                     @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo,
                                     Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                     @Cast("const sd::LongType*") long[] hDimensionShape, @Cast("const sd::LongType*") long[] dDimensionShape);

/**
 *
 * @param opNum
 * @param dx
 * @param xShapeInfo
 * @param y
 * @param yShapeInfo
 * @param result
 * @param resultShapeInfo
 * @param extraParams
 * @param n
 */
public native void execPairwiseTransform(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                         @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                         org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeInfo,
                                         @Cast("const sd::LongType*") LongPointer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                         @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo,
                                         Pointer extraParams);
public native void execPairwiseTransform(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                         @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                         org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeInfo,
                                         @Cast("const sd::LongType*") LongBuffer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                         @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo,
                                         Pointer extraParams);
public native void execPairwiseTransform(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                         @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                         org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeInfo,
                                         @Cast("const sd::LongType*") long[] dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                         @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo,
                                         Pointer extraParams);

public native void execPairwiseTransformBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                             @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                             org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeInfo,
                                             @Cast("const sd::LongType*") LongPointer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                             @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo,
                                             Pointer extraParams);
public native void execPairwiseTransformBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                             @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                             org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeInfo,
                                             @Cast("const sd::LongType*") LongBuffer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                             @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo,
                                             Pointer extraParams);
public native void execPairwiseTransformBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                             @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                             org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeInfo,
                                             @Cast("const sd::LongType*") long[] dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                             @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo,
                                             Pointer extraParams);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParams
 * @param result
 * @param resultShapeInfo
 */
public native void execReduceFloat(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongPointer dZShapeInfo);
public native void execReduceFloat(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongBuffer dZShapeInfo);
public native void execReduceFloat(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                   @Cast("const sd::LongType*") long[] dZShapeInfo);

public native void execReduceSame(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer dZShapeInfo);
public native void execReduceSame(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer dZShapeInfo);
public native void execReduceSame(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                  @Cast("const sd::LongType*") long[] dZShapeInfo);

public native void execReduceBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer dZShapeInfo);
public native void execReduceBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer dZShapeInfo);
public native void execReduceBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                  @Cast("const sd::LongType*") long[] dZShapeInfo);

public native void execReduceLong(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer dZShapeInfo);
public native void execReduceLong(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer dZShapeInfo);
public native void execReduceLong(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                  @Cast("const sd::LongType*") long[] dZShapeInfo);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParams
 * @param result
 * @param resultShapeInfo
 */
public native void execReduceFloat2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                    @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                    @Cast("const sd::LongType*") LongPointer hDimensionShape, @Cast("const sd::LongType*") LongPointer dDimensionShape);
public native void execReduceFloat2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                    @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                    @Cast("const sd::LongType*") LongBuffer hDimensionShape, @Cast("const sd::LongType*") LongBuffer dDimensionShape);
public native void execReduceFloat2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                    @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                    @Cast("const sd::LongType*") long[] hDimensionShape, @Cast("const sd::LongType*") long[] dDimensionShape);

public native void execReduceSame2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") LongPointer hDimensionShape, @Cast("const sd::LongType*") LongPointer dDimensionShape);
public native void execReduceSame2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") LongBuffer hDimensionShape, @Cast("const sd::LongType*") LongBuffer dDimensionShape);
public native void execReduceSame2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                   @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") long[] hDimensionShape, @Cast("const sd::LongType*") long[] dDimensionShape);

public native void execReduceBool2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") LongPointer hDimensionShape, @Cast("const sd::LongType*") LongPointer dDimensionShape);
public native void execReduceBool2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") LongBuffer hDimensionShape, @Cast("const sd::LongType*") LongBuffer dDimensionShape);
public native void execReduceBool2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                   @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") long[] hDimensionShape, @Cast("const sd::LongType*") long[] dDimensionShape);

public native void execReduceLong2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") LongPointer hDimensionShape, @Cast("const sd::LongType*") LongPointer dDimensionShape);
public native void execReduceLong2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                   @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") LongBuffer hDimensionShape, @Cast("const sd::LongType*") LongBuffer dDimensionShape);
public native void execReduceLong2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                   @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                   org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                   @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                   @Cast("const sd::LongType*") long[] hDimensionShape, @Cast("const sd::LongType*") long[] dDimensionShape);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParamsVals
 * @param y
 * @param yShapeInfo
 * @param result
 * @param resultShapeInfo
 */
public native void execReduce3(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParamsVals,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeInfo, @Cast("const sd::LongType*") LongPointer dYShapeInfo,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo);
public native void execReduce3(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParamsVals,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeInfo, @Cast("const sd::LongType*") LongBuffer dYShapeInfo,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo);
public native void execReduce3(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParamsVals,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeInfo, @Cast("const sd::LongType*") long[] dYShapeInfo,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParamsVals
 * @param y
 * @param yShapeInfo
 */
public native void execReduce3Scalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                     Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeInfo,
                                     @Cast("const sd::LongType*") LongPointer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                     @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo);
public native void execReduce3Scalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                     Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeInfo,
                                     @Cast("const sd::LongType*") LongBuffer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                     @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo);
public native void execReduce3Scalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                     Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeInfo,
                                     @Cast("const sd::LongType*") long[] dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                     @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo);
/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParamsVals
 * @param y
 * @param yShapeInfo
 * @param result
 * @param resultShapeInfoBuffer
 * @param dimension
 * @param dimensionLength
 */
public native void execReduce3Tad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                  Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                  @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") LongPointer hDimensionShape,
                                  @Cast("const sd::LongType*") LongPointer dDimensionShape, @Cast("const sd::LongType*") LongPointer tadOnlyShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer tadOffsets, @Cast("const sd::LongType*") LongPointer yTadOnlyShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer yTadOffsets);
public native void execReduce3Tad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                  Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                  @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") LongBuffer hDimensionShape,
                                  @Cast("const sd::LongType*") LongBuffer dDimensionShape, @Cast("const sd::LongType*") LongBuffer tadOnlyShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer tadOffsets, @Cast("const sd::LongType*") LongBuffer yTadOnlyShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer yTadOffsets);
public native void execReduce3Tad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                  Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeInfo,
                                  @Cast("const sd::LongType*") long[] dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                  @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") long[] hDimensionShape,
                                  @Cast("const sd::LongType*") long[] dDimensionShape, @Cast("const sd::LongType*") long[] tadOnlyShapeInfo,
                                  @Cast("const sd::LongType*") long[] tadOffsets, @Cast("const sd::LongType*") long[] yTadOnlyShapeInfo,
                                  @Cast("const sd::LongType*") long[] yTadOffsets);

public native void execReduce3All(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                  Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                  @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") LongPointer hDimensionShape,
                                  @Cast("const sd::LongType*") LongPointer dDimensionShape, @Cast("const sd::LongType*") LongPointer xTadShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer xOffsets, @Cast("const sd::LongType*") LongPointer yTadShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer yOffsets);
public native void execReduce3All(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                  Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                  @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") LongBuffer hDimensionShape,
                                  @Cast("const sd::LongType*") LongBuffer dDimensionShape, @Cast("const sd::LongType*") LongBuffer xTadShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer xOffsets, @Cast("const sd::LongType*") LongBuffer yTadShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer yOffsets);
public native void execReduce3All(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                  Pointer extraParamsVals, org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeInfo,
                                  @Cast("const sd::LongType*") long[] dYShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                                  @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") long[] hDimensionShape,
                                  @Cast("const sd::LongType*") long[] dDimensionShape, @Cast("const sd::LongType*") long[] xTadShapeInfo,
                                  @Cast("const sd::LongType*") long[] xOffsets, @Cast("const sd::LongType*") long[] yTadShapeInfo,
                                  @Cast("const sd::LongType*") long[] yOffsets);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param result
 * @param resultShapeInfo
 * @param scalar
 * @param extraParams
 * @param n
 */
public native void execScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                              @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                              @Cast("const sd::LongType*") LongPointer hZShapeInfo, @Cast("const sd::LongType*") LongPointer dZShapeInfo,
                              org.nd4j.nativeblas.OpaqueDataBuffer dbScalar, @Cast("const sd::LongType*") LongPointer hSscalarShapeInfo,
                              @Cast("const sd::LongType*") LongPointer dSscalarShapeInfo, Pointer extraParams);
public native void execScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                              @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                              @Cast("const sd::LongType*") LongBuffer hZShapeInfo, @Cast("const sd::LongType*") LongBuffer dZShapeInfo,
                              org.nd4j.nativeblas.OpaqueDataBuffer dbScalar, @Cast("const sd::LongType*") LongBuffer hSscalarShapeInfo,
                              @Cast("const sd::LongType*") LongBuffer dSscalarShapeInfo, Pointer extraParams);
public native void execScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                              @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                              @Cast("const sd::LongType*") long[] hZShapeInfo, @Cast("const sd::LongType*") long[] dZShapeInfo,
                              org.nd4j.nativeblas.OpaqueDataBuffer dbScalar, @Cast("const sd::LongType*") long[] hSscalarShapeInfo,
                              @Cast("const sd::LongType*") long[] dSscalarShapeInfo, Pointer extraParams);

public native void execScalarBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                  @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalar,
                                  @Cast("const sd::LongType*") LongPointer hSscalarShapeInfo, @Cast("const sd::LongType*") LongPointer dSscalarShapeInfo,
                                  Pointer extraParams);
public native void execScalarBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                  @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalar,
                                  @Cast("const sd::LongType*") LongBuffer hSscalarShapeInfo, @Cast("const sd::LongType*") LongBuffer dSscalarShapeInfo,
                                  Pointer extraParams);
public native void execScalarBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                  @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                  org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                  @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalar,
                                  @Cast("const sd::LongType*") long[] hSscalarShapeInfo, @Cast("const sd::LongType*") long[] dSscalarShapeInfo,
                                  Pointer extraParams);

/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParams
 */
public native void execSummaryStatsScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                          @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                          Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                          @Cast("const sd::LongType*") LongPointer dZShapeInfo, @Cast("bool") boolean biasCorrected);
public native void execSummaryStatsScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                          @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                          Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                          @Cast("const sd::LongType*") LongBuffer dZShapeInfo, @Cast("bool") boolean biasCorrected);
public native void execSummaryStatsScalar(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                          @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                          Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                          @Cast("const sd::LongType*") long[] dZShapeInfo, @Cast("bool") boolean biasCorrected);
/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParams
 * @param result
 * @param resultShapeInfo
 */
public native void execSummaryStats(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo, Pointer extraParams,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                    @Cast("const sd::LongType*") LongPointer dZShapeInfo, @Cast("bool") boolean biasCorrected);
public native void execSummaryStats(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo, Pointer extraParams,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                    @Cast("const sd::LongType*") LongBuffer dZShapeInfo, @Cast("bool") boolean biasCorrected);
public native void execSummaryStats(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo, Pointer extraParams,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                    @Cast("const sd::LongType*") long[] dZShapeInfo, @Cast("bool") boolean biasCorrected);
/**
 *
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param extraParams
 * @param result
 * @param resultShapeInfoBuffer
 * @param dimension
 * @param dimensionLength
 */
public native void execSummaryStatsTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                       @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                       Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                       @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                       @Cast("const sd::LongType*") LongPointer hDimensionShape, @Cast("const sd::LongType*") LongPointer dDimensionShape,
                                       @Cast("bool") boolean biasCorrected, @Cast("const sd::LongType*") LongPointer tadShapeInfo,
                                       @Cast("const sd::LongType*") LongPointer tadOffsets);
public native void execSummaryStatsTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                       @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                       Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                       @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                       @Cast("const sd::LongType*") LongBuffer hDimensionShape, @Cast("const sd::LongType*") LongBuffer dDimensionShape,
                                       @Cast("bool") boolean biasCorrected, @Cast("const sd::LongType*") LongBuffer tadShapeInfo,
                                       @Cast("const sd::LongType*") LongBuffer tadOffsets);
public native void execSummaryStatsTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                       @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                       Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                       @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                       @Cast("const sd::LongType*") long[] hDimensionShape, @Cast("const sd::LongType*") long[] dDimensionShape,
                                       @Cast("bool") boolean biasCorrected, @Cast("const sd::LongType*") long[] tadShapeInfo,
                                       @Cast("const sd::LongType*") long[] tadOffsets);

/**
 *
 * @param opNum
 * @param dx
 * @param xShapeInfo
 * @param result
 * @param resultShapeInfo
 * @param extraParams
 * @param n
 */
public native void execTransformFloat(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                      @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                      org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                      @Cast("const sd::LongType*") LongPointer dZShapeInfo, Pointer extraParams);
public native void execTransformFloat(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                      @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                      org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                      @Cast("const sd::LongType*") LongBuffer dZShapeInfo, Pointer extraParams);
public native void execTransformFloat(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                      @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                      org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                      @Cast("const sd::LongType*") long[] dZShapeInfo, Pointer extraParams);

public native void execTransformSame(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                     @Cast("const sd::LongType*") LongPointer dZShapeInfo, Pointer extraParams);
public native void execTransformSame(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                     @Cast("const sd::LongType*") LongBuffer dZShapeInfo, Pointer extraParams);
public native void execTransformSame(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                     @Cast("const sd::LongType*") long[] dZShapeInfo, Pointer extraParams);

public native void execTransformBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                     @Cast("const sd::LongType*") LongPointer dZShapeInfo, Pointer extraParams);
public native void execTransformBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                     @Cast("const sd::LongType*") LongBuffer dZShapeInfo, Pointer extraParams);
public native void execTransformBool(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                     @Cast("const sd::LongType*") long[] dZShapeInfo, Pointer extraParams);

public native void execTransformAny(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                    @Cast("const sd::LongType*") LongPointer dZShapeInfo, Pointer extraParams);
public native void execTransformAny(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                    @Cast("const sd::LongType*") LongBuffer dZShapeInfo, Pointer extraParams);
public native void execTransformAny(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                    @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                    org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                    @Cast("const sd::LongType*") long[] dZShapeInfo, Pointer extraParams);

public native void execTransformStrict(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                       @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                       org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                       @Cast("const sd::LongType*") LongPointer dZShapeInfo, Pointer extraParams);
public native void execTransformStrict(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                       @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                       org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                       @Cast("const sd::LongType*") LongBuffer dZShapeInfo, Pointer extraParams);
public native void execTransformStrict(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                       @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                       org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                       @Cast("const sd::LongType*") long[] dZShapeInfo, Pointer extraParams);

/**
 *
 * @param extraPointers
 * @param opNum
 * @param x
 * @param xShapeInfo
 * @param z
 * @param zShapeInfo
 * @param scalars
 * @param extraParams
 * @param dimension
 * @param dimensionLength
 */
public native void execScalarTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                 @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                 @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalars,
                                 @Cast("const sd::LongType*") LongPointer hScalarShapeInfo, @Cast("const sd::LongType*") LongPointer dScalarShapeInfo,
                                 Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") LongPointer hDimensionShape,
                                 @Cast("const sd::LongType*") LongPointer dDimensionShape, @Cast("const sd::LongType*") LongPointer tadShapeInfo,
                                 @Cast("const sd::LongType*") LongPointer tadOffsets, @Cast("const sd::LongType*") LongPointer tadShapeInfoZ,
                                 @Cast("const sd::LongType*") LongPointer tadOffsetsZ);
public native void execScalarTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                 @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                 @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalars,
                                 @Cast("const sd::LongType*") LongBuffer hScalarShapeInfo, @Cast("const sd::LongType*") LongBuffer dScalarShapeInfo,
                                 Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") LongBuffer hDimensionShape,
                                 @Cast("const sd::LongType*") LongBuffer dDimensionShape, @Cast("const sd::LongType*") LongBuffer tadShapeInfo,
                                 @Cast("const sd::LongType*") LongBuffer tadOffsets, @Cast("const sd::LongType*") LongBuffer tadShapeInfoZ,
                                 @Cast("const sd::LongType*") LongBuffer tadOffsetsZ);
public native void execScalarTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                 @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                 org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                 @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalars,
                                 @Cast("const sd::LongType*") long[] hScalarShapeInfo, @Cast("const sd::LongType*") long[] dScalarShapeInfo,
                                 Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension, @Cast("const sd::LongType*") long[] hDimensionShape,
                                 @Cast("const sd::LongType*") long[] dDimensionShape, @Cast("const sd::LongType*") long[] tadShapeInfo,
                                 @Cast("const sd::LongType*") long[] tadOffsets, @Cast("const sd::LongType*") long[] tadShapeInfoZ,
                                 @Cast("const sd::LongType*") long[] tadOffsetsZ);

public native void execScalarBoolTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeInfo,
                                     @Cast("const sd::LongType*") LongPointer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalars,
                                     @Cast("const sd::LongType*") LongPointer hScalarShapeInfo, @Cast("const sd::LongType*") LongPointer dScalarShapeInfo,
                                     Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                     @Cast("const sd::LongType*") LongPointer hDimensionShape, @Cast("const sd::LongType*") LongPointer dDimensionShape,
                                     @Cast("const sd::LongType*") LongPointer tadShapeInfo, @Cast("const sd::LongType*") LongPointer tadOffsets,
                                     @Cast("const sd::LongType*") LongPointer tadShapeInfoZ, @Cast("const sd::LongType*") LongPointer tadOffsetsZ);
public native void execScalarBoolTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeInfo,
                                     @Cast("const sd::LongType*") LongBuffer dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalars,
                                     @Cast("const sd::LongType*") LongBuffer hScalarShapeInfo, @Cast("const sd::LongType*") LongBuffer dScalarShapeInfo,
                                     Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                     @Cast("const sd::LongType*") LongBuffer hDimensionShape, @Cast("const sd::LongType*") LongBuffer dDimensionShape,
                                     @Cast("const sd::LongType*") LongBuffer tadShapeInfo, @Cast("const sd::LongType*") LongBuffer tadOffsets,
                                     @Cast("const sd::LongType*") LongBuffer tadShapeInfoZ, @Cast("const sd::LongType*") LongBuffer tadOffsetsZ);
public native void execScalarBoolTad(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                                     @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] dXShapeInfo,
                                     org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeInfo,
                                     @Cast("const sd::LongType*") long[] dZShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbScalars,
                                     @Cast("const sd::LongType*") long[] hScalarShapeInfo, @Cast("const sd::LongType*") long[] dScalarShapeInfo,
                                     Pointer extraParams, org.nd4j.nativeblas.OpaqueDataBuffer dbDimension,
                                     @Cast("const sd::LongType*") long[] hDimensionShape, @Cast("const sd::LongType*") long[] dDimensionShape,
                                     @Cast("const sd::LongType*") long[] tadShapeInfo, @Cast("const sd::LongType*") long[] tadOffsets,
                                     @Cast("const sd::LongType*") long[] tadShapeInfoZ, @Cast("const sd::LongType*") long[] tadOffsetsZ);

public native void specialConcat(@Cast("sd::Pointer*") PointerPointer extraPointers, int dimension, int numArrays, @Cast("sd::Pointer*") PointerPointer data,
                                 @Cast("sd::Pointer*") PointerPointer inputShapeInfo, Pointer result, @Cast("const sd::LongType*") LongPointer resultShapeInfo,
                                 @Cast("sd::Pointer*") PointerPointer tadPointers, @Cast("sd::Pointer*") PointerPointer offsetPointers);
public native void specialConcat(@Cast("sd::Pointer*") PointerPointer extraPointers, int dimension, int numArrays, @Cast("sd::Pointer*") PointerPointer data,
                                 @Cast("sd::Pointer*") PointerPointer inputShapeInfo, Pointer result, @Cast("const sd::LongType*") LongBuffer resultShapeInfo,
                                 @Cast("sd::Pointer*") PointerPointer tadPointers, @Cast("sd::Pointer*") PointerPointer offsetPointers);
public native void specialConcat(@Cast("sd::Pointer*") PointerPointer extraPointers, int dimension, int numArrays, @Cast("sd::Pointer*") PointerPointer data,
                                 @Cast("sd::Pointer*") PointerPointer inputShapeInfo, Pointer result, @Cast("const sd::LongType*") long[] resultShapeInfo,
                                 @Cast("sd::Pointer*") PointerPointer tadPointers, @Cast("sd::Pointer*") PointerPointer offsetPointers);

/**
 * This method implementation exists only for cuda.
 * The other backends should have dummy method for JNI compatibility reasons.
 */
public native void initializeDevicesAndFunctions();

public native void initializeFunctions(@Cast("sd::Pointer*") PointerPointer functions);

/**
 * This method acquires memory chunk of requested size on host side
 *
 * @param pointer pointer that'll be used for allocation
 * @param memorySize memory size, in bytes
 * @param flags optional parameter
 */
public native @Cast("sd::Pointer") Pointer mallocHost(@Cast("sd::LongType") long memorySize, int flags);

/**
 * This method acquires memory chunk of requested size on specified device
 *
 * @param pointer pointer that'll be used for allocation
 * @param memorySize memory size, in bytes
 * @param ptrToDeviceId pointer to deviceId. For cuda that's just and int, for OpenCL that's pointer to device_id, etc
 * @param flags optional parameter
 */
public native @Cast("sd::Pointer") Pointer mallocDevice(@Cast("sd::LongType") long memorySize, int deviceId, int flags);

/**
 * This method releases previously allocated host memory space
 *
 * @param pointer pointer that'll be freed
 */
public native int freeHost(@Cast("sd::Pointer") Pointer pointer);

/**
 * This method releases previously allocated memory space on device
 *
 * @param pointer pointer that'll be freed
 * @param ptrToDeviceId pointer to deviceId.
 */
public native int freeDevice(@Cast("sd::Pointer") Pointer pointer, int deviceId);

/**
 *
 * @return
 */
public native int ompGetMaxThreads();

/**
 *
 * @return
 */
public native int ompGetNumThreads();

/**
 *
 * @param threads
 */
public native void setOmpNumThreads(int threads);

/**
 *
 * @param threads
 */
public native void setOmpMinThreads(int threads);

public native @Cast("bool") boolean isBlasVersionMatches(int major, int minor, int build);

/**
 *
 * @return
 */
public native @Cast("sd::Pointer") Pointer createContext();

/**
 *
 * @return
 */
public native @Cast("sd::Pointer") Pointer createStream();

/**
 *
 * @return
 */
public native @Cast("sd::Pointer") Pointer createEvent();

/**
 *
 * @param event
 * @param stream
 * @return
 */
public native int registerEvent(@Cast("sd::Pointer") Pointer event, @Cast("sd::Pointer") Pointer stream);

/**
 *
 * @param event
 * @return
 */
public native int destroyEvent(@Cast("sd::Pointer") Pointer event);

/**
 *
 * @param ptrToDeviceId
 * @return
 */
public native int setDevice(int deviceId);

/**
 *
 * @return
 */
public native int getDevice();

/**
 *
 * @param stream
 * @return
 */
public native int streamSynchronize(@Cast("sd::Pointer") Pointer stream);

/**
 *
 * @param event
 * @return
 */
public native int eventSynchronize(@Cast("sd::Pointer") Pointer event);

/**
 *
 * @param ptrToDeviceId
 * @return
 */
public native @Cast("sd::LongType") long getDeviceFreeMemory(int deviceId);

/**
 * Returns amount of free memory for current device
 * @return
 */
public native @Cast("sd::LongType") long getDeviceFreeMemoryDefault();

/**
 *
 * @param ptrToDeviceId
 * @return
 */
public native @Cast("sd::LongType") long getDeviceTotalMemory(int deviceId);

/**
 *
 * @param ptrToDeviceId
 * @return
 */
public native int getDeviceMajor(int deviceId);

/**
 * This method returns amount of cached memory
 * @param deviceId
 * @return
 */
public native @Cast("sd::LongType") long getCachedMemory(int deviceId);

/**
 *
 * @param ptrToDeviceId
 * @return
 */
public native int getDeviceMinor(int deviceId);

/**
 *
 * @param ptrToDeviceId
 * @return
 */
public native @Cast("char*") String getDeviceName(int deviceId);

/**
 *
 * @param dst
 * @param src
 * @param size
 * @param flags
 * @param reserved
 * @return
 */
public native int memcpySync(@Cast("sd::Pointer") Pointer dst, @Cast("sd::Pointer") Pointer src, @Cast("sd::LongType") long size, int flags, @Cast("sd::Pointer") Pointer reserved);

/**
 *
 * @param dst
 * @param src
 * @param size
 * @param flags
 * @param reserved
 * @return
 */
public native int memcpyAsync(@Cast("sd::Pointer") Pointer dst, @Cast("sd::Pointer") Pointer src, @Cast("sd::LongType") long size, int flags, @Cast("sd::Pointer") Pointer reserved);

/**
 *
 * @param dst
 * @param value
 * @param size
 * @param flags
 * @param reserved
 * @return
 */
public native int memsetSync(@Cast("sd::Pointer") Pointer dst, int value, @Cast("sd::LongType") long size, int flags, @Cast("sd::Pointer") Pointer reserved);

/**
 *
 * @param dst
 * @param value
 * @param size
 * @param flags
 * @param reserved
 * @return
 */
public native int memsetAsync(@Cast("sd::Pointer") Pointer dst, int value, @Cast("sd::LongType") long size, int flags, @Cast("sd::Pointer") Pointer reserved);

/**
 *
 * @param dst
 * @param src
 * @param size
 * @param flags
 * @param reserved
 * @return
 */
public native int memcpyConstantAsync(@Cast("sd::LongType") long dst, @Cast("sd::Pointer") Pointer src, @Cast("sd::LongType") long size, int flags,
                                      @Cast("sd::Pointer") Pointer reserved);

/**
 *
 * @return
 */
public native @Cast("sd::Pointer") Pointer getConstantSpace();

/**
 *
 * @return
 */
public native int getAvailableDevices();

/**
 *
 * @param reallyEnable
 */
public native void enableDebugMode(@Cast("bool") boolean reallyEnable);

/**
 *
 * @param reallyEnable
 */
public native void enableVerboseMode(@Cast("bool") boolean reallyEnable);

/**
 *
 * @param gridSize
 */
public native void setGridLimit(int gridSize);

/**
 *
 * @param xShapeInfo
 * @param dimension
 * @param dimensionLength
 * @param targetBuffer
 * @param offsetsBuffer
 */
public native org.nd4j.nativeblas.OpaqueTadPack tadOnlyShapeInfo(@Cast("const sd::LongType*") LongPointer xShapeInfo, IntPointer dimension, int dimensionLength);
public native org.nd4j.nativeblas.OpaqueTadPack tadOnlyShapeInfo(@Cast("const sd::LongType*") LongBuffer xShapeInfo, IntBuffer dimension, int dimensionLength);
public native org.nd4j.nativeblas.OpaqueTadPack tadOnlyShapeInfo(@Cast("const sd::LongType*") long[] xShapeInfo, int[] dimension, int dimensionLength);

public native @Cast("const sd::LongType*") LongPointer getPrimaryShapeInfo(org.nd4j.nativeblas.OpaqueTadPack pack);
public native @Cast("const sd::LongType*") LongPointer getPrimaryOffsets(org.nd4j.nativeblas.OpaqueTadPack pack);
public native @Cast("const sd::LongType*") LongPointer getSpecialShapeInfo(org.nd4j.nativeblas.OpaqueTadPack pack);
public native @Cast("const sd::LongType*") LongPointer getSpecialOffsets(org.nd4j.nativeblas.OpaqueTadPack pack);
public native @Cast("sd::LongType") long getNumberOfTads(org.nd4j.nativeblas.OpaqueTadPack pack);
public native int getShapeInfoLength(org.nd4j.nativeblas.OpaqueTadPack pack);

public native void deleteTadPack(org.nd4j.nativeblas.OpaqueTadPack ptr);

/*
 * PullRow special op
 */

/**
 *
 * @param extraPointers
 * @param x
 * @param xShapeInfo
 * @param z
 * @param zShapeInfo
 * @param n
 * @param indexes
 * @param tadShapeInfo
 * @param tadOffsets
 * @param zTadShapeInfo
 * @param zTadOffsets
 */
public native void pullRows(@Cast("sd::Pointer*") PointerPointer extraPointers, org.nd4j.nativeblas.OpaqueDataBuffer dbX, @Cast("const sd::LongType*") LongPointer xShapeInfo,
                            @Cast("const sd::LongType*") LongPointer dxShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer zShapeInfo,
                            @Cast("const sd::LongType*") LongPointer dzShapeInfo, @Cast("sd::LongType") long n, @Cast("sd::LongType*") LongPointer indexes,
                            @Cast("const sd::LongType*") LongPointer tadShapeInfo, @Cast("const sd::LongType*") LongPointer tadOffsets,
                            @Cast("const sd::LongType*") LongPointer zTadShapeInfo, @Cast("const sd::LongType*") LongPointer zTadOffsets);
public native void pullRows(@Cast("sd::Pointer*") PointerPointer extraPointers, org.nd4j.nativeblas.OpaqueDataBuffer dbX, @Cast("const sd::LongType*") LongBuffer xShapeInfo,
                            @Cast("const sd::LongType*") LongBuffer dxShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer zShapeInfo,
                            @Cast("const sd::LongType*") LongBuffer dzShapeInfo, @Cast("sd::LongType") long n, @Cast("sd::LongType*") LongBuffer indexes,
                            @Cast("const sd::LongType*") LongBuffer tadShapeInfo, @Cast("const sd::LongType*") LongBuffer tadOffsets,
                            @Cast("const sd::LongType*") LongBuffer zTadShapeInfo, @Cast("const sd::LongType*") LongBuffer zTadOffsets);
public native void pullRows(@Cast("sd::Pointer*") PointerPointer extraPointers, org.nd4j.nativeblas.OpaqueDataBuffer dbX, @Cast("const sd::LongType*") long[] xShapeInfo,
                            @Cast("const sd::LongType*") long[] dxShapeInfo, org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] zShapeInfo,
                            @Cast("const sd::LongType*") long[] dzShapeInfo, @Cast("sd::LongType") long n, @Cast("sd::LongType*") long[] indexes,
                            @Cast("const sd::LongType*") long[] tadShapeInfo, @Cast("const sd::LongType*") long[] tadOffsets,
                            @Cast("const sd::LongType*") long[] zTadShapeInfo, @Cast("const sd::LongType*") long[] zTadOffsets);

/**
 *
 * @param extras
 * @param dx
 * @param dz
 * @param n
 * @param length
 * @param propagate
 */
public native void average(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                           @Cast("const sd::LongType*") LongPointer dxShapeInfo, Pointer z, @Cast("const sd::LongType*") LongPointer zShapeInfo, Pointer dz,
                           @Cast("const sd::LongType*") LongPointer dzShapeInfo, int n, @Cast("sd::LongType") long length, @Cast("bool") boolean propagate);
public native void average(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                           @Cast("const sd::LongType*") LongBuffer dxShapeInfo, Pointer z, @Cast("const sd::LongType*") LongBuffer zShapeInfo, Pointer dz,
                           @Cast("const sd::LongType*") LongBuffer dzShapeInfo, int n, @Cast("sd::LongType") long length, @Cast("bool") boolean propagate);
public native void average(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("const sd::LongType*") long[] xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                           @Cast("const sd::LongType*") long[] dxShapeInfo, Pointer z, @Cast("const sd::LongType*") long[] zShapeInfo, Pointer dz,
                           @Cast("const sd::LongType*") long[] dzShapeInfo, int n, @Cast("sd::LongType") long length, @Cast("bool") boolean propagate);

public native void accumulate(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                              @Cast("const sd::LongType*") LongPointer dxShapeInfo, Pointer z, @Cast("const sd::LongType*") LongPointer zShapeInfo, Pointer dz,
                              @Cast("const sd::LongType*") LongPointer dzShapeInfo, int n, @Cast("sd::LongType") long length);
public native void accumulate(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                              @Cast("const sd::LongType*") LongBuffer dxShapeInfo, Pointer z, @Cast("const sd::LongType*") LongBuffer zShapeInfo, Pointer dz,
                              @Cast("const sd::LongType*") LongBuffer dzShapeInfo, int n, @Cast("sd::LongType") long length);
public native void accumulate(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("const sd::LongType*") long[] xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                              @Cast("const sd::LongType*") long[] dxShapeInfo, Pointer z, @Cast("const sd::LongType*") long[] zShapeInfo, Pointer dz,
                              @Cast("const sd::LongType*") long[] dzShapeInfo, int n, @Cast("sd::LongType") long length);

/**
 * P2P enabler
 */
/**
 *
 * @param enable
 */
public native void enableP2P(@Cast("bool") boolean enable);

/**
 *
 */
public native void checkP2P();

/**
 *
 * @return
 */
public native @Cast("bool") boolean isP2PAvailable();

/**
 * Shuffle methods
 */

/**
 *
 * @param extras
 * @param dx
 * @param xShapeInfo
 * @param dz
 * @param zShapeInfo
 * @param N
 * @param shuffleMap
 * @param tadShapeInfo
 * @param tadOffsets
 */
public native void shuffle(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("sd::Pointer*") PointerPointer xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                           @Cast("sd::Pointer*") PointerPointer dxShapeInfo, @Cast("sd::Pointer*") PointerPointer z, @Cast("sd::Pointer*") PointerPointer zShapeInfo, @Cast("sd::Pointer*") PointerPointer dz,
                           @Cast("sd::Pointer*") PointerPointer dzShapeInfo, int N, IntPointer shuffleMap, @Cast("sd::Pointer*") PointerPointer tadShapeInfo,
                           @Cast("sd::Pointer*") PointerPointer tadOffsets);
public native void shuffle(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("sd::Pointer*") PointerPointer xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                           @Cast("sd::Pointer*") PointerPointer dxShapeInfo, @Cast("sd::Pointer*") PointerPointer z, @Cast("sd::Pointer*") PointerPointer zShapeInfo, @Cast("sd::Pointer*") PointerPointer dz,
                           @Cast("sd::Pointer*") PointerPointer dzShapeInfo, int N, IntBuffer shuffleMap, @Cast("sd::Pointer*") PointerPointer tadShapeInfo,
                           @Cast("sd::Pointer*") PointerPointer tadOffsets);
public native void shuffle(@Cast("sd::Pointer*") PointerPointer extras, @Cast("sd::Pointer*") PointerPointer x, @Cast("sd::Pointer*") PointerPointer xShapeInfo, @Cast("sd::Pointer*") PointerPointer dx,
                           @Cast("sd::Pointer*") PointerPointer dxShapeInfo, @Cast("sd::Pointer*") PointerPointer z, @Cast("sd::Pointer*") PointerPointer zShapeInfo, @Cast("sd::Pointer*") PointerPointer dz,
                           @Cast("sd::Pointer*") PointerPointer dzShapeInfo, int N, int[] shuffleMap, @Cast("sd::Pointer*") PointerPointer tadShapeInfo,
                           @Cast("sd::Pointer*") PointerPointer tadOffsets);

/**
 * Type Conversions
 */

/**
 *
 * @param extras
 * @param srcType
 * @param x
 * @param N
 * @param dstType
 * @param z
 */
public native void convertTypes(@Cast("sd::Pointer*") PointerPointer extras, int srcType, @Cast("sd::Pointer") Pointer x, @Cast("sd::LongType") long N, int dstType,
                                @Cast("sd::Pointer") Pointer z);

/**
 *
 * @return
 */
public native @Cast("bool") boolean isExperimentalEnabled();

/**
 * Aggregate
 */

/**
 *
 * @param extraPointers
 * @param opNum
 * @param arguments
 * @param numArguments
 * @param shapeArguments
 * @param numShapeArguments
 * @param indexArguments
 * @param numIndexArguments
 * @param intArrays
 * @param numIntArrays
 * @param realArguments
 * @param numRealArguments
 */
public native void execAggregate(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("void**") PointerPointer arguments, int numArguments,
                                 @Cast("sd::LongType**") PointerPointer shapeArguments, int numShapeArguments, IntPointer indexArguments,
                                 int numIndexArguments, @Cast("int**") PointerPointer intArrays, int numIntArrays, Pointer realArguments,
                                 int numRealArguments, @Cast("sd::DataType") int dtype);
public native void execAggregate(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("void**") @ByPtrPtr Pointer arguments, int numArguments,
                                 @Cast("sd::LongType**") @ByPtrPtr LongPointer shapeArguments, int numShapeArguments, IntPointer indexArguments,
                                 int numIndexArguments, @ByPtrPtr IntPointer intArrays, int numIntArrays, Pointer realArguments,
                                 int numRealArguments, @Cast("sd::DataType") int dtype);
public native void execAggregate(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("void**") @ByPtrPtr Pointer arguments, int numArguments,
                                 @Cast("sd::LongType**") @ByPtrPtr LongBuffer shapeArguments, int numShapeArguments, IntBuffer indexArguments,
                                 int numIndexArguments, @ByPtrPtr IntBuffer intArrays, int numIntArrays, Pointer realArguments,
                                 int numRealArguments, @Cast("sd::DataType") int dtype);
public native void execAggregate(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("void**") @ByPtrPtr Pointer arguments, int numArguments,
                                 @Cast("sd::LongType**") @ByPtrPtr long[] shapeArguments, int numShapeArguments, int[] indexArguments,
                                 int numIndexArguments, @ByPtrPtr int[] intArrays, int numIntArrays, Pointer realArguments,
                                 int numRealArguments, @Cast("sd::DataType") int dtype);

public native void batchExecutor(@Cast("sd::Pointer*") PointerPointer extraPointers, int numAggregates, int opNum, int maxArgs, int maxShapes,
                                 int maxIntArrays, int maxIntArraySize, int maxIdx, int maxReals, Pointer ptrToArguments,
                                 @Cast("sd::DataType") int dtype);

public native void execAggregateBatch(@Cast("sd::Pointer*") PointerPointer extraPointers, int numAggregates, int opNum, int maxArgs,
                                      int maxShapes, int maxIntArrays, int maxIntArraySize, int maxIdx, int maxReals,
                                      Pointer ptrToArguments, @Cast("sd::DataType") int dtype);

/**
 * Random operations
 */

/**
 *
 * @param extraPointers
 * @param opNum
 * @param state
 * @param z
 * @param zShapeBuffer
 * @param extraArguments
 */
public native void execRandom(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                              @Cast("const sd::LongType*") LongPointer hZShapeBuffer, @Cast("const sd::LongType*") LongPointer dZShapeBuffer,
                              Pointer extraArguments);
public native void execRandom(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                              @Cast("const sd::LongType*") LongBuffer hZShapeBuffer, @Cast("const sd::LongType*") LongBuffer dZShapeBuffer,
                              Pointer extraArguments);
public native void execRandom(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                              @Cast("const sd::LongType*") long[] hZShapeBuffer, @Cast("const sd::LongType*") long[] dZShapeBuffer,
                              Pointer extraArguments);

/**
 *
 * @param extraPointers
 * @param opNum
 * @param state
 * @param x
 * @param xShapeBuffer
 * @param y
 * @param yShapeBuffer
 * @param z
 * @param zShapeBuffer
 * @param extraArguments
 */
public native void execRandom3(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") LongPointer hXShapeBuffer, @Cast("const sd::LongType*") LongPointer dXShapeBuffer,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongPointer hYShapeBuffer,
                               @Cast("const sd::LongType*") LongPointer dYShapeBuffer, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                               @Cast("const sd::LongType*") LongPointer hZShapeBuffer, @Cast("const sd::LongType*") LongPointer dZShapeBuffer,
                               Pointer extraArguments);
public native void execRandom3(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") LongBuffer hXShapeBuffer, @Cast("const sd::LongType*") LongBuffer dXShapeBuffer,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") LongBuffer hYShapeBuffer,
                               @Cast("const sd::LongType*") LongBuffer dYShapeBuffer, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                               @Cast("const sd::LongType*") LongBuffer hZShapeBuffer, @Cast("const sd::LongType*") LongBuffer dZShapeBuffer,
                               Pointer extraArguments);
public native void execRandom3(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") long[] hXShapeBuffer, @Cast("const sd::LongType*") long[] dXShapeBuffer,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbY, @Cast("const sd::LongType*") long[] hYShapeBuffer,
                               @Cast("const sd::LongType*") long[] dYShapeBuffer, org.nd4j.nativeblas.OpaqueDataBuffer dbZ,
                               @Cast("const sd::LongType*") long[] hZShapeBuffer, @Cast("const sd::LongType*") long[] dZShapeBuffer,
                               Pointer extraArguments);

/**
 *
 * @param extraPointers
 * @param opNum
 * @param state
 * @param x
 * @param xShapeBuffer
 * @param z
 * @param zShapeBuffer
 * @param extraArguments
 */
public native void execRandom2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") LongPointer hXShapeBuffer, @Cast("const sd::LongType*") LongPointer dXShapeBuffer,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongPointer hZShapeBuffer,
                               @Cast("const sd::LongType*") LongPointer dZShapeBuffer, Pointer extraArguments);
public native void execRandom2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") LongBuffer hXShapeBuffer, @Cast("const sd::LongType*") LongBuffer dXShapeBuffer,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") LongBuffer hZShapeBuffer,
                               @Cast("const sd::LongType*") LongBuffer dZShapeBuffer, Pointer extraArguments);
public native void execRandom2(@Cast("sd::Pointer*") PointerPointer extraPointers, int opNum, @Cast("sd::Pointer") Pointer state, org.nd4j.nativeblas.OpaqueDataBuffer dbX,
                               @Cast("const sd::LongType*") long[] hXShapeBuffer, @Cast("const sd::LongType*") long[] dXShapeBuffer,
                               org.nd4j.nativeblas.OpaqueDataBuffer dbZ, @Cast("const sd::LongType*") long[] hZShapeBuffer,
                               @Cast("const sd::LongType*") long[] dZShapeBuffer, Pointer extraArguments);

/**
 *
 * @param extraPointers
 * @param seed
 * @param bufferSize
 * @param ptrToBuffer
 * @return
 */
public native @Cast("sd::Pointer") Pointer initRandom(@Cast("sd::Pointer*") PointerPointer extraPointers, long seed, long bufferSize, @Cast("sd::Pointer") Pointer ptrToBuffer);

/**
 *
 * @param extraPointers
 * @param seed
 * @param ptrRandom
 */
public native void refreshBuffer(@Cast("sd::Pointer*") PointerPointer extraPointers, long seed, @Cast("sd::Pointer") Pointer ptrRandom);

/**
 *
 * @param extraPointers
 * @param seed
 * @param ptrRandom
 */
public native void reSeedBuffer(@Cast("sd::Pointer*") PointerPointer extraPointers, long seed, @Cast("sd::Pointer") Pointer ptrRandom);

/**
 *
 * @param ptrRandom
 */
public native void destroyRandom(@Cast("sd::Pointer") Pointer ptrRandom);

/**
 *
 * @param data
 * @param shapeBuffer
 * @param wordSize
 * @param headerSize
 * @return
 */

public native @Cast("sd::Pointer") Pointer numpyHeaderForNd4j(@Cast("sd::Pointer") Pointer data, @Cast("sd::Pointer") Pointer shapeBuffer, @Cast("sd::LongType") long wordSize,
                                      @Cast("sd::LongType*") LongPointer headerSize);
public native @Cast("sd::Pointer") Pointer numpyHeaderForNd4j(@Cast("sd::Pointer") Pointer data, @Cast("sd::Pointer") Pointer shapeBuffer, @Cast("sd::LongType") long wordSize,
                                      @Cast("sd::LongType*") LongBuffer headerSize);
public native @Cast("sd::Pointer") Pointer numpyHeaderForNd4j(@Cast("sd::Pointer") Pointer data, @Cast("sd::Pointer") Pointer shapeBuffer, @Cast("sd::LongType") long wordSize,
                                      @Cast("sd::LongType*") long[] headerSize);

/**
 * Load numpy from a header
 * based on the cnpy parse from header method.
 * @param data the header data to parse
 * @return a pointer to a numpy cnpy:NpyArray struct
 */
public native @Cast("sd::Pointer") Pointer loadNpyFromHeader(@Cast("sd::Pointer") Pointer data);

/**
 * Create a numpy array from an nd4j
 * array
 * @param data a pointer to the data
 * @param shapeBuffer  the shapebuffer for the nd4j array
 * @param wordSize  the word size (4 for float, 8 for doubles)
 * @return a pointer to a numpy array
 */

public native @Cast("sd::Pointer") Pointer numpyFromNd4j(@Cast("sd::Pointer") Pointer data, @Cast("sd::Pointer") Pointer shapeBuffer, @Cast("sd::LongType") long wordSize);

/**
 *
 * @param npyArray
 * @return
 */
public native @Cast("sd::Pointer") Pointer shapeBufferForNumpy(@Cast("sd::Pointer") Pointer npyArray);

/**
 * Get the shape buffer from a
 * numpy array.
 * **Warning** this allocates memory
 * @param npyArray
 * @return
 */
public native @Cast("sd::Pointer") Pointer shapeBufferForNumpyHeader(@Cast("sd::Pointer") Pointer npyArray);

/**
 *
 * @param npyArray
 * @return
 */
public native @Cast("sd::Pointer") Pointer dataPointForNumpyHeader(@Cast("sd::Pointer") Pointer npyArray);

/**
 *
 * @param npyArray
 * @return
 */
public native @Cast("sd::Pointer") Pointer dataPointForNumpyStruct(@Cast("sd::Pointer") Pointer npyArrayStruct);

/**
 *
 * @param npyArray
 * @param fromFile
 * @return
 */
public native @Cast("sd::Pointer") Pointer dataPointForNumpy(@Cast("sd::Pointer") Pointer npyArray);

/**
 * Load a numpy array from a file
 * and return it as an sd::Pointer
 * @param path
 * @return
 */
public native @Cast("sd::Pointer") Pointer numpyFromFile(@StdString BytePointer path);
public native @Cast("sd::Pointer") Pointer numpyFromFile(@StdString String path);

////// NPZ //////

public native Pointer mapFromNpzFile(@StdString BytePointer path);
public native Pointer mapFromNpzFile(@StdString String path);

public native int getNumNpyArraysInMap(Pointer map);

public native @Cast("char*") String getNpyArrayNameFromMap(Pointer map, int index, @Cast("char*") BytePointer nameBuffer);
public native @Cast("char*") BytePointer getNpyArrayNameFromMap(Pointer map, int index, @Cast("char*") String nameBuffer);

public native Pointer getNpyArrayFromMap(Pointer map, int index);

public native int dataTypeFromNpyHeader(Pointer header);

public native Pointer getNpyArrayData(Pointer npArray);

public native int getNpyArrayRank(Pointer npArray);

public native @Cast("sd::LongType*") LongPointer getNpyArrayShape(Pointer npArray);

public native char getNpyArrayOrder(Pointer npArray);

public native int getNpyArrayElemSize(Pointer npArray);

public native void deleteNPArrayStruct(Pointer npArray);

public native void deleteNPArrayMap(Pointer map);
//////

/**
 * Get the element size for a numpy array
 * @param npyArray  the numpy array's address
 * to get the length for
 * @return
 */
public native int elementSizeForNpyArray(@Cast("sd::Pointer") Pointer npyArray);

/**
 * Get the element size for a numpy array
 * @param npyArray  the numpy array's address
 * to get the length for
 * @return
 */
public native int elementSizeForNpyArrayHeader(@Cast("sd::Pointer") Pointer npyArray);

public native void releaseNumpy(@Cast("sd::Pointer") Pointer npyArray);

/**
 * Return the length of a shape buffer
 * based on the pointer
 * @param buffer  the buffer pointer to check
 * @return
 */
public native int lengthForShapeBufferPointer(@Cast("sd::Pointer") Pointer buffer);

/**
 * The pointer to get the address for
 *
 * @param address the address to get the pointer
 * @return the pointer for the given address
 */

public native @Cast("sd::Pointer") Pointer pointerForAddress(@Cast("sd::LongType") long _address);

/**
 * This method takes single N-dimensional tensor, and copies its TADs to target arrays
 *
 * @param x
 * @param xShapeInfo
 * @param targets
 * @param zShapeInfo
 * @return
 */
public native void tear(@Cast("sd::Pointer*") PointerPointer extraPointers, org.nd4j.nativeblas.OpaqueDataBuffer dbX, @Cast("const sd::LongType*") LongPointer xShapeInfo,
                        @Cast("const sd::LongType*") LongPointer dxShapeInfo, @Cast("sd::Pointer*") PointerPointer targets, @Cast("const sd::LongType*") LongPointer zShapeInfo,
                        @Cast("const sd::LongType*") LongPointer tadShapeInfo, @Cast("const sd::LongType*") LongPointer tadOffsets);
public native void tear(@Cast("sd::Pointer*") PointerPointer extraPointers, org.nd4j.nativeblas.OpaqueDataBuffer dbX, @Cast("const sd::LongType*") LongBuffer xShapeInfo,
                        @Cast("const sd::LongType*") LongBuffer dxShapeInfo, @Cast("sd::Pointer*") PointerPointer targets, @Cast("const sd::LongType*") LongBuffer zShapeInfo,
                        @Cast("const sd::LongType*") LongBuffer tadShapeInfo, @Cast("const sd::LongType*") LongBuffer tadOffsets);
public native void tear(@Cast("sd::Pointer*") PointerPointer extraPointers, org.nd4j.nativeblas.OpaqueDataBuffer dbX, @Cast("const sd::LongType*") long[] xShapeInfo,
                        @Cast("const sd::LongType*") long[] dxShapeInfo, @Cast("sd::Pointer*") PointerPointer targets, @Cast("const sd::LongType*") long[] zShapeInfo,
                        @Cast("const sd::LongType*") long[] tadShapeInfo, @Cast("const sd::LongType*") long[] tadOffsets);

public native void sort(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, Pointer dx,
                        @Cast("const sd::LongType*") LongPointer dxShapeInfo, @Cast("bool") boolean descending);
public native void sort(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, Pointer dx,
                        @Cast("const sd::LongType*") LongBuffer dxShapeInfo, @Cast("bool") boolean descending);
public native void sort(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") long[] xShapeInfo, Pointer dx,
                        @Cast("const sd::LongType*") long[] dxShapeInfo, @Cast("bool") boolean descending);

public native void sortByKey(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, Pointer dx,
                             @Cast("const sd::LongType*") LongPointer dxShapeInfo, Pointer y, @Cast("const sd::LongType*") LongPointer yShapeInfo, Pointer dy,
                             @Cast("const sd::LongType*") LongPointer dyShapeInfo, @Cast("bool") boolean descending);
public native void sortByKey(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, Pointer dx,
                             @Cast("const sd::LongType*") LongBuffer dxShapeInfo, Pointer y, @Cast("const sd::LongType*") LongBuffer yShapeInfo, Pointer dy,
                             @Cast("const sd::LongType*") LongBuffer dyShapeInfo, @Cast("bool") boolean descending);
public native void sortByKey(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") long[] xShapeInfo, Pointer dx,
                             @Cast("const sd::LongType*") long[] dxShapeInfo, Pointer y, @Cast("const sd::LongType*") long[] yShapeInfo, Pointer dy,
                             @Cast("const sd::LongType*") long[] dyShapeInfo, @Cast("bool") boolean descending);

public native void sortByValue(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, Pointer dx,
                               @Cast("const sd::LongType*") LongPointer dxShapeInfo, Pointer y, @Cast("const sd::LongType*") LongPointer yShapeInfo, Pointer dy,
                               @Cast("const sd::LongType*") LongPointer dyShapeInfo, @Cast("bool") boolean descending);
public native void sortByValue(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, Pointer dx,
                               @Cast("const sd::LongType*") LongBuffer dxShapeInfo, Pointer y, @Cast("const sd::LongType*") LongBuffer yShapeInfo, Pointer dy,
                               @Cast("const sd::LongType*") LongBuffer dyShapeInfo, @Cast("bool") boolean descending);
public native void sortByValue(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") long[] xShapeInfo, Pointer dx,
                               @Cast("const sd::LongType*") long[] dxShapeInfo, Pointer y, @Cast("const sd::LongType*") long[] yShapeInfo, Pointer dy,
                               @Cast("const sd::LongType*") long[] dyShapeInfo, @Cast("bool") boolean descending);

public native void sortTad(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, Pointer dx,
                           @Cast("const sd::LongType*") LongPointer dxShapeInfo, IntPointer dimension, int dimensionLength,
                           @Cast("const sd::LongType*") LongPointer tadShapeInfo, @Cast("const sd::LongType*") LongPointer tadOffsets, @Cast("bool") boolean descending);
public native void sortTad(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, Pointer dx,
                           @Cast("const sd::LongType*") LongBuffer dxShapeInfo, IntBuffer dimension, int dimensionLength,
                           @Cast("const sd::LongType*") LongBuffer tadShapeInfo, @Cast("const sd::LongType*") LongBuffer tadOffsets, @Cast("bool") boolean descending);
public native void sortTad(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") long[] xShapeInfo, Pointer dx,
                           @Cast("const sd::LongType*") long[] dxShapeInfo, int[] dimension, int dimensionLength,
                           @Cast("const sd::LongType*") long[] tadShapeInfo, @Cast("const sd::LongType*") long[] tadOffsets, @Cast("bool") boolean descending);

public native void sortTadByKey(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, Pointer dx,
                                @Cast("const sd::LongType*") LongPointer dxShapeInfo, Pointer y, @Cast("const sd::LongType*") LongPointer yShapeInfo, Pointer dy,
                                @Cast("const sd::LongType*") LongPointer dyShapeInfo, IntPointer dimension, int dimensionLength, @Cast("bool") boolean descending);
public native void sortTadByKey(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, Pointer dx,
                                @Cast("const sd::LongType*") LongBuffer dxShapeInfo, Pointer y, @Cast("const sd::LongType*") LongBuffer yShapeInfo, Pointer dy,
                                @Cast("const sd::LongType*") LongBuffer dyShapeInfo, IntBuffer dimension, int dimensionLength, @Cast("bool") boolean descending);
public native void sortTadByKey(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") long[] xShapeInfo, Pointer dx,
                                @Cast("const sd::LongType*") long[] dxShapeInfo, Pointer y, @Cast("const sd::LongType*") long[] yShapeInfo, Pointer dy,
                                @Cast("const sd::LongType*") long[] dyShapeInfo, int[] dimension, int dimensionLength, @Cast("bool") boolean descending);

public native void sortTadByValue(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, Pointer dx,
                                  @Cast("const sd::LongType*") LongPointer dxShapeInfo, Pointer y, @Cast("const sd::LongType*") LongPointer yShapeInfo, Pointer dy,
                                  @Cast("const sd::LongType*") LongPointer dyShapeInfo, IntPointer dimension, int dimensionLength,
                                  @Cast("bool") boolean descending);
public native void sortTadByValue(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, Pointer dx,
                                  @Cast("const sd::LongType*") LongBuffer dxShapeInfo, Pointer y, @Cast("const sd::LongType*") LongBuffer yShapeInfo, Pointer dy,
                                  @Cast("const sd::LongType*") LongBuffer dyShapeInfo, IntBuffer dimension, int dimensionLength,
                                  @Cast("bool") boolean descending);
public native void sortTadByValue(@Cast("sd::Pointer*") PointerPointer extraPointers, Pointer x, @Cast("const sd::LongType*") long[] xShapeInfo, Pointer dx,
                                  @Cast("const sd::LongType*") long[] dxShapeInfo, Pointer y, @Cast("const sd::LongType*") long[] yShapeInfo, Pointer dy,
                                  @Cast("const sd::LongType*") long[] dyShapeInfo, int[] dimension, int dimensionLength,
                                  @Cast("bool") boolean descending);

// special sort impl for sorting out COO indices and values
public native void sortCooIndices(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") LongPointer indices, Pointer x, @Cast("sd::LongType") long length,
                                  @Cast("const sd::LongType*") LongPointer xShapeInfo);
public native void sortCooIndices(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") LongBuffer indices, Pointer x, @Cast("sd::LongType") long length,
                                  @Cast("const sd::LongType*") LongBuffer xShapeInfo);
public native void sortCooIndices(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") long[] indices, Pointer x, @Cast("sd::LongType") long length,
                                  @Cast("const sd::LongType*") long[] xShapeInfo);

/**
 *
 * @param extraPointers     not used
 * @param indices           DataBuffer containing COO indices for a sparse matrix that is to be raveled/flattened
 * @param flatIndices       DataBuffer where the raveled/flattened indices are to be written to
 * @param length            number of non-zero entries (length of flatIndices)
 * @param fullShapeBuffer   DataBuffer with ShapeInfo for the full matrix to be flattened
 * @param mode              clipMode determines the strategy to use if some of the the passed COO indices does
 *                          not fit into the shape determined by fullShapeBuffer
 *                              0   throw an exception (default)
 *                              1   wrap around shape
 *                              2   clip to shape
 */
public native void ravelMultiIndex(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") LongPointer indices, @Cast("sd::LongType*") LongPointer flatIndices,
                                   @Cast("sd::LongType") long length, @Cast("sd::LongType*") LongPointer shapeInfo, int mode);
public native void ravelMultiIndex(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") LongBuffer indices, @Cast("sd::LongType*") LongBuffer flatIndices,
                                   @Cast("sd::LongType") long length, @Cast("sd::LongType*") LongBuffer shapeInfo, int mode);
public native void ravelMultiIndex(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") long[] indices, @Cast("sd::LongType*") long[] flatIndices,
                                   @Cast("sd::LongType") long length, @Cast("sd::LongType*") long[] shapeInfo, int mode);

/**
 *
 * @param extraPointers     not used
 * @param indices           DataBuffer where the unraveled COO indices are to be written
 * @param flatIndices       DataBuffer containing the raveled/flattened indices to be unravel
 * @param length            number of non-zero entries (length of flatIndices)
 * @param fullShapeBuffer   DataBuffer with ShapeInfo for the full matrix to be unraveled
 */
public native void unravelIndex(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") LongPointer indices, @Cast("sd::LongType*") LongPointer flatIndices,
                                @Cast("sd::LongType") long length, @Cast("sd::LongType*") LongPointer shapeInfo);
public native void unravelIndex(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") LongBuffer indices, @Cast("sd::LongType*") LongBuffer flatIndices,
                                @Cast("sd::LongType") long length, @Cast("sd::LongType*") LongBuffer shapeInfo);
public native void unravelIndex(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") long[] indices, @Cast("sd::LongType*") long[] flatIndices,
                                @Cast("sd::LongType") long length, @Cast("sd::LongType*") long[] shapeInfo);

public native @Cast("sd::LongType*") LongPointer mmapFile(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("char*") String fileName, @Cast("sd::LongType") long length);
public native @Cast("sd::LongType*") LongBuffer mmapFile(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("char*") BytePointer fileName, @Cast("sd::LongType") long length);

public native void munmapFile(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") LongPointer ptrMap, @Cast("sd::LongType") long length);
public native void munmapFile(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") LongBuffer ptrMap, @Cast("sd::LongType") long length);
public native void munmapFile(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType*") long[] ptrMap, @Cast("sd::LongType") long length);

// flatbuffers execution
public native org.nd4j.nativeblas.OpaqueResultWrapper executeFlatGraph(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer flatBufferPointer);

public native @Cast("sd::LongType") long getResultWrapperSize(org.nd4j.nativeblas.OpaqueResultWrapper ptr);
public native @Cast("sd::Pointer") Pointer getResultWrapperPointer(org.nd4j.nativeblas.OpaqueResultWrapper ptr);

public native @Cast("char*") String getAllCustomOps();

public native @Cast("char*") String getAllOperations();

// customOp executioner
public native @Cast("sd::Status") int execCustomOp(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs, DoublePointer tArgs, int numTArgs,
                                      @Cast("sd::LongType*") LongPointer iArgs, int numIArgs, @Cast("bool*") BooleanPointer bArgs, int numBArgs, @Cast("bool") boolean isInplace);
public native @Cast("sd::Status") int execCustomOp(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs, DoubleBuffer tArgs, int numTArgs,
                                      @Cast("sd::LongType*") LongBuffer iArgs, int numIArgs, @Cast("bool*") boolean[] bArgs, int numBArgs, @Cast("bool") boolean isInplace);
public native @Cast("sd::Status") int execCustomOp(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs, double[] tArgs, int numTArgs,
                                      @Cast("sd::LongType*") long[] iArgs, int numIArgs, @Cast("bool*") BooleanPointer bArgs, int numBArgs, @Cast("bool") boolean isInplace);
public native @Cast("sd::Status") int execCustomOp(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs, DoublePointer tArgs, int numTArgs,
                                      @Cast("sd::LongType*") LongPointer iArgs, int numIArgs, @Cast("bool*") boolean[] bArgs, int numBArgs, @Cast("bool") boolean isInplace);
public native @Cast("sd::Status") int execCustomOp(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs, DoubleBuffer tArgs, int numTArgs,
                                      @Cast("sd::LongType*") LongBuffer iArgs, int numIArgs, @Cast("bool*") BooleanPointer bArgs, int numBArgs, @Cast("bool") boolean isInplace);
public native @Cast("sd::Status") int execCustomOp(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                      @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs, double[] tArgs, int numTArgs,
                                      @Cast("sd::LongType*") long[] iArgs, int numIArgs, @Cast("bool*") boolean[] bArgs, int numBArgs, @Cast("bool") boolean isInplace);
public native @Cast("sd::Status") int execCustomOp2(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash, @Cast("sd::Pointer") Pointer opContext);

public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                     @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputShapes, DoublePointer tArgs,
                                                     int numTArgs, @Cast("sd::LongType*") LongPointer iArgs, int numIArgs);
public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                     @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputShapes, DoubleBuffer tArgs,
                                                     int numTArgs, @Cast("sd::LongType*") LongBuffer iArgs, int numIArgs);
public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                     @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputShapes, double[] tArgs,
                                                     int numTArgs, @Cast("sd::LongType*") long[] iArgs, int numIArgs);
public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes2(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                      @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                      int numInputShapes, DoublePointer tArgs, int numTArgs,
                                                      @Cast("sd::LongType*") LongPointer iArgs, int numIArgs, @Cast("bool*") BooleanPointer bArgs, int numBArgs,
                                                      IntPointer dArgs, int numDArgs);
public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes2(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                      @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                      int numInputShapes, DoubleBuffer tArgs, int numTArgs,
                                                      @Cast("sd::LongType*") LongBuffer iArgs, int numIArgs, @Cast("bool*") boolean[] bArgs, int numBArgs,
                                                      IntBuffer dArgs, int numDArgs);
public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes2(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                      @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                      int numInputShapes, double[] tArgs, int numTArgs,
                                                      @Cast("sd::LongType*") long[] iArgs, int numIArgs, @Cast("bool*") BooleanPointer bArgs, int numBArgs,
                                                      int[] dArgs, int numDArgs);
public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes2(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                      @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                      int numInputShapes, DoublePointer tArgs, int numTArgs,
                                                      @Cast("sd::LongType*") LongPointer iArgs, int numIArgs, @Cast("bool*") boolean[] bArgs, int numBArgs,
                                                      IntPointer dArgs, int numDArgs);
public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes2(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                      @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                      int numInputShapes, DoubleBuffer tArgs, int numTArgs,
                                                      @Cast("sd::LongType*") LongBuffer iArgs, int numIArgs, @Cast("bool*") BooleanPointer bArgs, int numBArgs,
                                                      IntBuffer dArgs, int numDArgs);
public native org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes2(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long hash,
                                                      @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                      int numInputShapes, double[] tArgs, int numTArgs,
                                                      @Cast("sd::LongType*") long[] iArgs, int numIArgs, @Cast("bool*") boolean[] bArgs, int numBArgs,
                                                      int[] dArgs, int numDArgs);
// #ifdef __NEC__
// #endif
public native @Cast("sd::LongType") long getShapeListSize(org.nd4j.nativeblas.OpaqueShapeList list);
public native @Cast("const sd::LongType*") LongPointer getShape(org.nd4j.nativeblas.OpaqueShapeList list, @Cast("sd::LongType") long i);

public native void deleteShapeList(@Cast("sd::Pointer") Pointer shapeList);

public native @Cast("sd::Status") int registerGraph(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long graphId, @Cast("sd::Pointer") Pointer flatBufferPointer);

public native org.nd4j.nativeblas.OpaqueVariablesSet executeStoredGraph(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long graphId,
                                                     @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                     IntPointer inputIndices, int numInputs);
public native org.nd4j.nativeblas.OpaqueVariablesSet executeStoredGraph(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long graphId,
                                                     @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                     IntBuffer inputIndices, int numInputs);
public native org.nd4j.nativeblas.OpaqueVariablesSet executeStoredGraph(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long graphId,
                                                     @Cast("sd::Pointer*") PointerPointer inputBuffers, @Cast("sd::Pointer*") PointerPointer inputShapes,
                                                     int[] inputIndices, int numInputs);

public native @Cast("sd::LongType") long getVariablesSetSize(org.nd4j.nativeblas.OpaqueVariablesSet set);
public native @Cast("sd::Status") int getVariablesSetStatus(org.nd4j.nativeblas.OpaqueVariablesSet set);
public native org.nd4j.nativeblas.OpaqueVariable getVariable(org.nd4j.nativeblas.OpaqueVariablesSet set, @Cast("sd::LongType") long i);
public native int getVariableId(org.nd4j.nativeblas.OpaqueVariable variable);
public native int getVariableIndex(org.nd4j.nativeblas.OpaqueVariable variable);
public native @Cast("char*") String getVariableName(org.nd4j.nativeblas.OpaqueVariable variable);
public native @Cast("const sd::LongType*") LongPointer getVariableShape(org.nd4j.nativeblas.OpaqueVariable variable);
public native Pointer getVariableBuffer(org.nd4j.nativeblas.OpaqueVariable variable);

public native @Cast("sd::Status") int unregisterGraph(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::LongType") long graphId);

public native void deleteCharArray(@Cast("sd::Pointer") Pointer pointer);
public native void deleteIntArray(@Cast("sd::Pointer") Pointer pointer);
public native void deleteLongArray(@Cast("sd::Pointer") Pointer pointer);
public native void deletePointerArray(@Cast("sd::Pointer") Pointer pointer);

public native void deleteVariablesSet(org.nd4j.nativeblas.OpaqueVariablesSet pointer);

// GraphState creation
public native @Cast("sd::Pointer") Pointer getGraphState(@Cast("sd::LongType") long id);

public native void deleteGraphState(@Cast("sd::Pointer") Pointer state);

public native void deleteResultWrapper(@Cast("sd::Pointer") Pointer ptr);

public native int estimateThreshold(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer x, @Cast("const sd::LongType*") LongPointer xShapeInfo, int N,
                                    float threshold);
public native int estimateThreshold(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer x, @Cast("const sd::LongType*") LongBuffer xShapeInfo, int N,
                                    float threshold);
public native int estimateThreshold(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer x, @Cast("const sd::LongType*") long[] xShapeInfo, int N,
                                    float threshold);

// this method executes op that requires scope to be present: if/while/cond/whatever
public native @Cast("sd::Status") int execCustomOpWithScope(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer state, @Cast("sd::LongType") long opHash,
                                               @Cast("sd::LongType*") LongPointer scopes, int numScopes, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                               @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                               @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs);
public native @Cast("sd::Status") int execCustomOpWithScope(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer state, @Cast("sd::LongType") long opHash,
                                               @Cast("sd::LongType*") LongBuffer scopes, int numScopes, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                               @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                               @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs);
public native @Cast("sd::Status") int execCustomOpWithScope(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer state, @Cast("sd::LongType") long opHash,
                                               @Cast("sd::LongType*") long[] scopes, int numScopes, @Cast("sd::Pointer*") PointerPointer inputBuffers,
                                               @Cast("sd::Pointer*") PointerPointer inputShapes, int numInputs, @Cast("sd::Pointer*") PointerPointer outputBuffers,
                                               @Cast("sd::Pointer*") PointerPointer outputShapes, int numOutputs);

// void fillUtf8String(sd::Pointer *extraPointers, const char **string, int numStrings, sd::Pointer buffer);
public native @Cast("sd::Pointer") Pointer createUtf8String(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("char*") String string, int length);
public native @Cast("sd::Pointer") Pointer createUtf8String(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("char*") BytePointer string, int length);
public native @Cast("sd::LongType") long getUtf8StringLength(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer ptr);
public native @Cast("char*") BytePointer getUtf8StringBuffer(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer ptr);
public native void deleteUtf8String(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer ptr);

public native void scatterUpdate(@Cast("sd::Pointer*") PointerPointer extraPointers, int opCode, int numOfSubArrs, Pointer hX,
                                 @Cast("const sd::LongType*") LongPointer hXShapeInfo, @Cast("const sd::LongType*") LongPointer hXOffsets, Pointer dX,
                                 @Cast("const sd::LongType*") LongPointer dXShapeInfo, @Cast("const sd::LongType*") LongPointer dXOffsets, Pointer hY,
                                 @Cast("const sd::LongType*") LongPointer hYShapeInfo, @Cast("const sd::LongType*") LongPointer hYOffsets, Pointer dY,
                                 @Cast("const sd::LongType*") LongPointer dYShapeInfo, @Cast("const sd::LongType*") LongPointer dYOffsets, Pointer hIindexes,
                                 @Cast("const sd::LongType*") LongPointer hIndicesShapeInfo, Pointer dIindexes,
                                 @Cast("const sd::LongType*") LongPointer dIndicesShapeInfo);
public native void scatterUpdate(@Cast("sd::Pointer*") PointerPointer extraPointers, int opCode, int numOfSubArrs, Pointer hX,
                                 @Cast("const sd::LongType*") LongBuffer hXShapeInfo, @Cast("const sd::LongType*") LongBuffer hXOffsets, Pointer dX,
                                 @Cast("const sd::LongType*") LongBuffer dXShapeInfo, @Cast("const sd::LongType*") LongBuffer dXOffsets, Pointer hY,
                                 @Cast("const sd::LongType*") LongBuffer hYShapeInfo, @Cast("const sd::LongType*") LongBuffer hYOffsets, Pointer dY,
                                 @Cast("const sd::LongType*") LongBuffer dYShapeInfo, @Cast("const sd::LongType*") LongBuffer dYOffsets, Pointer hIindexes,
                                 @Cast("const sd::LongType*") LongBuffer hIndicesShapeInfo, Pointer dIindexes,
                                 @Cast("const sd::LongType*") LongBuffer dIndicesShapeInfo);
public native void scatterUpdate(@Cast("sd::Pointer*") PointerPointer extraPointers, int opCode, int numOfSubArrs, Pointer hX,
                                 @Cast("const sd::LongType*") long[] hXShapeInfo, @Cast("const sd::LongType*") long[] hXOffsets, Pointer dX,
                                 @Cast("const sd::LongType*") long[] dXShapeInfo, @Cast("const sd::LongType*") long[] dXOffsets, Pointer hY,
                                 @Cast("const sd::LongType*") long[] hYShapeInfo, @Cast("const sd::LongType*") long[] hYOffsets, Pointer dY,
                                 @Cast("const sd::LongType*") long[] dYShapeInfo, @Cast("const sd::LongType*") long[] dYOffsets, Pointer hIindexes,
                                 @Cast("const sd::LongType*") long[] hIndicesShapeInfo, Pointer dIindexes,
                                 @Cast("const sd::LongType*") long[] dIndicesShapeInfo);

public native void inspectArray(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer buffer, @Cast("sd::LongType*") LongPointer shapeInfo,
                                @Cast("sd::Pointer") Pointer specialBuffer, @Cast("sd::LongType*") LongPointer specialShapeInfo, @Cast("sd::Pointer") Pointer debugInfo);
public native void inspectArray(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer buffer, @Cast("sd::LongType*") LongBuffer shapeInfo,
                                @Cast("sd::Pointer") Pointer specialBuffer, @Cast("sd::LongType*") LongBuffer specialShapeInfo, @Cast("sd::Pointer") Pointer debugInfo);
public native void inspectArray(@Cast("sd::Pointer*") PointerPointer extraPointers, @Cast("sd::Pointer") Pointer buffer, @Cast("sd::LongType*") long[] shapeInfo,
                                @Cast("sd::Pointer") Pointer specialBuffer, @Cast("sd::LongType*") long[] specialShapeInfo, @Cast("sd::Pointer") Pointer debugInfo);

public native org.nd4j.nativeblas.OpaqueConstantShapeBuffer shapeBuffer(int rank, @Cast("sd::LongType*") LongPointer shape, @Cast("sd::LongType*") LongPointer strides,
                                                     @Cast("sd::DataType") int dtype, char order, @Cast("sd::LongType") long ews, @Cast("bool") boolean empty);
public native org.nd4j.nativeblas.OpaqueConstantShapeBuffer shapeBuffer(int rank, @Cast("sd::LongType*") LongBuffer shape, @Cast("sd::LongType*") LongBuffer strides,
                                                     @Cast("sd::DataType") int dtype, char order, @Cast("sd::LongType") long ews, @Cast("bool") boolean empty);
public native org.nd4j.nativeblas.OpaqueConstantShapeBuffer shapeBuffer(int rank, @Cast("sd::LongType*") long[] shape, @Cast("sd::LongType*") long[] strides,
                                                     @Cast("sd::DataType") int dtype, char order, @Cast("sd::LongType") long ews, @Cast("bool") boolean empty);
public native org.nd4j.nativeblas.OpaqueConstantShapeBuffer shapeBufferEx(int rank, @Cast("sd::LongType*") LongPointer shape, @Cast("sd::LongType*") LongPointer strides,
                                                       @Cast("sd::DataType") int dtype, char order, @Cast("sd::LongType") long ews,
                                                       @Cast("sd::LongType") long extras);
public native org.nd4j.nativeblas.OpaqueConstantShapeBuffer shapeBufferEx(int rank, @Cast("sd::LongType*") LongBuffer shape, @Cast("sd::LongType*") LongBuffer strides,
                                                       @Cast("sd::DataType") int dtype, char order, @Cast("sd::LongType") long ews,
                                                       @Cast("sd::LongType") long extras);
public native org.nd4j.nativeblas.OpaqueConstantShapeBuffer shapeBufferEx(int rank, @Cast("sd::LongType*") long[] shape, @Cast("sd::LongType*") long[] strides,
                                                       @Cast("sd::DataType") int dtype, char order, @Cast("sd::LongType") long ews,
                                                       @Cast("sd::LongType") long extras);

public native org.nd4j.nativeblas.OpaqueConstantDataBuffer constantBufferLong(@Cast("sd::DataType") int dtype, @Cast("const sd::LongType*") LongPointer data, int length);
public native org.nd4j.nativeblas.OpaqueConstantDataBuffer constantBufferLong(@Cast("sd::DataType") int dtype, @Cast("const sd::LongType*") LongBuffer data, int length);
public native org.nd4j.nativeblas.OpaqueConstantDataBuffer constantBufferLong(@Cast("sd::DataType") int dtype, @Cast("const sd::LongType*") long[] data, int length);
public native org.nd4j.nativeblas.OpaqueConstantDataBuffer constantBufferDouble(@Cast("sd::DataType") int dtype, DoublePointer data, int length);
public native org.nd4j.nativeblas.OpaqueConstantDataBuffer constantBufferDouble(@Cast("sd::DataType") int dtype, DoubleBuffer data, int length);
public native org.nd4j.nativeblas.OpaqueConstantDataBuffer constantBufferDouble(@Cast("sd::DataType") int dtype, double[] data, int length);
public native org.nd4j.nativeblas.OpaqueConstantDataBuffer constantBuffer(@Cast("sd::DataType") int dtype, ConstantDescriptor descriptor);

public native @Cast("sd::Pointer") Pointer getConstantDataBufferPrimary(org.nd4j.nativeblas.OpaqueConstantDataBuffer dbf);
public native @Cast("sd::Pointer") Pointer getConstantDataBufferSpecial(org.nd4j.nativeblas.OpaqueConstantDataBuffer dbf);
public native @Cast("sd::LongType") long getConstantDataBufferLength(org.nd4j.nativeblas.OpaqueConstantDataBuffer dbf);

public native @Cast("sd::Pointer") Pointer getConstantShapeBufferPrimary(org.nd4j.nativeblas.OpaqueConstantShapeBuffer dbf);
public native @Cast("sd::Pointer") Pointer getConstantShapeBufferSpecial(org.nd4j.nativeblas.OpaqueConstantShapeBuffer dbf);

public native void deleteConstantShapeBuffer(org.nd4j.nativeblas.OpaqueConstantShapeBuffer ptr);
public native void deleteConstantDataBuffer(org.nd4j.nativeblas.OpaqueConstantDataBuffer ptr);

public native org.nd4j.nativeblas.OpaqueContext createGraphContext(int nodeId);
public native org.nd4j.nativeblas.OpaqueRandomGenerator getGraphContextRandomGenerator(org.nd4j.nativeblas.OpaqueContext ptr);
public native void ctxAllowHelpers(org.nd4j.nativeblas.OpaqueContext ptr, @Cast("bool") boolean reallyAllow);
public native void ctxShapeFunctionOverride(org.nd4j.nativeblas.OpaqueContext ptr, @Cast("bool") boolean reallyOverride);
public native void ctxSetExecutionMode(org.nd4j.nativeblas.OpaqueContext ptr, int execMode);
public native void ctxPurge(org.nd4j.nativeblas.OpaqueContext ptr);
public native void markGraphContextInplace(org.nd4j.nativeblas.OpaqueContext ptr, @Cast("bool") boolean reallyInplace);
public native void setGraphContextCudaContext(org.nd4j.nativeblas.OpaqueContext ptr, Pointer stream, Pointer reductionPointer,
                                              Pointer allocationPointer);
public native void setGraphContextInputArray(org.nd4j.nativeblas.OpaqueContext ptr, int index, Pointer buffer, Pointer shapeInfo,
                                             Pointer specialBuffer, Pointer specialShapeInfo);
public native void setGraphContextOutputArray(org.nd4j.nativeblas.OpaqueContext ptr, int index, Pointer buffer, Pointer shapeInfo,
                                              Pointer specialBuffer, Pointer specialShapeInfo);
public native void setGraphContextInputBuffer(org.nd4j.nativeblas.OpaqueContext ptr, int index, org.nd4j.nativeblas.OpaqueDataBuffer buffer, Pointer shapeInfo,
                                              Pointer specialShapeInfo);
public native void setGraphContextOutputBuffer(org.nd4j.nativeblas.OpaqueContext ptr, int index, org.nd4j.nativeblas.OpaqueDataBuffer buffer, Pointer shapeInfo,
                                               Pointer specialShapeInfo);
public native void setGraphContextDArguments(org.nd4j.nativeblas.OpaqueContext ptr, IntPointer arguments, int numberOfArguments);
public native void setGraphContextDArguments(org.nd4j.nativeblas.OpaqueContext ptr, IntBuffer arguments, int numberOfArguments);
public native void setGraphContextDArguments(org.nd4j.nativeblas.OpaqueContext ptr, int[] arguments, int numberOfArguments);
public native void setGraphContextTArguments(org.nd4j.nativeblas.OpaqueContext ptr, DoublePointer arguments, int numberOfArguments);
public native void setGraphContextTArguments(org.nd4j.nativeblas.OpaqueContext ptr, DoubleBuffer arguments, int numberOfArguments);
public native void setGraphContextTArguments(org.nd4j.nativeblas.OpaqueContext ptr, double[] arguments, int numberOfArguments);
public native void setGraphContextIArguments(org.nd4j.nativeblas.OpaqueContext ptr, @Cast("sd::LongType*") LongPointer arguments, int numberOfArguments);
public native void setGraphContextIArguments(org.nd4j.nativeblas.OpaqueContext ptr, @Cast("sd::LongType*") LongBuffer arguments, int numberOfArguments);
public native void setGraphContextIArguments(org.nd4j.nativeblas.OpaqueContext ptr, @Cast("sd::LongType*") long[] arguments, int numberOfArguments);
public native void setGraphContextBArguments(org.nd4j.nativeblas.OpaqueContext ptr, @Cast("bool*") BooleanPointer arguments, int numberOfArguments);
public native void setGraphContextBArguments(org.nd4j.nativeblas.OpaqueContext ptr, @Cast("bool*") boolean[] arguments, int numberOfArguments);
public native void deleteGraphContext(org.nd4j.nativeblas.OpaqueContext ptr);

public native org.nd4j.nativeblas.OpaqueRandomGenerator createRandomGenerator(@Cast("sd::LongType") long rootSeed/*=0*/, @Cast("sd::LongType") long nodeSeed/*=0*/);
public native org.nd4j.nativeblas.OpaqueRandomGenerator createRandomGenerator();
public native @Cast("sd::LongType") long getRandomGeneratorRootState(org.nd4j.nativeblas.OpaqueRandomGenerator ptr);
public native @Cast("sd::LongType") long getRandomGeneratorNodeState(org.nd4j.nativeblas.OpaqueRandomGenerator ptr);
public native void setRandomGeneratorStates(org.nd4j.nativeblas.OpaqueRandomGenerator ptr, @Cast("sd::LongType") long rootSeed/*=0*/,
                                            @Cast("sd::LongType") long nodeSeed/*=0*/);
public native void setRandomGeneratorStates(org.nd4j.nativeblas.OpaqueRandomGenerator ptr);
public native float getRandomGeneratorRelativeFloat(org.nd4j.nativeblas.OpaqueRandomGenerator ptr, @Cast("sd::LongType") long index);
public native double getRandomGeneratorRelativeDouble(org.nd4j.nativeblas.OpaqueRandomGenerator ptr, @Cast("sd::LongType") long index);
public native int getRandomGeneratorRelativeInt(org.nd4j.nativeblas.OpaqueRandomGenerator ptr, @Cast("sd::LongType") long index);
public native @Cast("sd::LongType") long getRandomGeneratorRelativeLong(org.nd4j.nativeblas.OpaqueRandomGenerator ptr, @Cast("sd::LongType") long index);
public native float getRandomGeneratorNextFloat(org.nd4j.nativeblas.OpaqueRandomGenerator ptr);
public native double getRandomGeneratorNextDouble(org.nd4j.nativeblas.OpaqueRandomGenerator ptr);
public native int getRandomGeneratorNextInt(org.nd4j.nativeblas.OpaqueRandomGenerator ptr);
public native @Cast("sd::LongType") long getRandomGeneratorNextLong(org.nd4j.nativeblas.OpaqueRandomGenerator ptr);
public native void deleteRandomGenerator(org.nd4j.nativeblas.OpaqueRandomGenerator ptr);

public native org.nd4j.nativeblas.OpaqueLaunchContext defaultLaunchContext();
public native @Cast("sd::Pointer") Pointer lcScalarPointer(org.nd4j.nativeblas.OpaqueLaunchContext lc);
public native @Cast("sd::Pointer") Pointer lcReductionPointer(org.nd4j.nativeblas.OpaqueLaunchContext lc);
public native @Cast("sd::Pointer") Pointer lcAllocationPointer(org.nd4j.nativeblas.OpaqueLaunchContext lc);
public native @Cast("sd::Pointer") Pointer lcExecutionStream(org.nd4j.nativeblas.OpaqueLaunchContext lc);
public native @Cast("sd::Pointer") Pointer lcCopyStream(org.nd4j.nativeblas.OpaqueLaunchContext lc);
public native @Cast("sd::Pointer") Pointer lcBlasHandle(org.nd4j.nativeblas.OpaqueLaunchContext lc);
public native @Cast("sd::Pointer") Pointer lcSolverHandle(org.nd4j.nativeblas.OpaqueLaunchContext lc);

public native org.nd4j.nativeblas.OpaqueDataBuffer allocateDataBuffer(@Cast("sd::LongType") long elements, int dataType, @Cast("bool") boolean allocateBoth);
public native org.nd4j.nativeblas.OpaqueDataBuffer dbAllocateDataBuffer(@Cast("sd::LongType") long elements, int dataType, @Cast("bool") boolean allocateBoth);
public native org.nd4j.nativeblas.OpaqueDataBuffer dbCreateExternalDataBuffer(@Cast("sd::LongType") long elements, int dataType, @Cast("sd::Pointer") Pointer primary,
                                                           @Cast("sd::Pointer") Pointer special);
public native int dbUseCount(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native org.nd4j.nativeblas.OpaqueDataBuffer dbCreateView(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer, @Cast("sd::LongType") long length, @Cast("sd::LongType") long offset);
public native @Cast("sd::Pointer") Pointer dbPrimaryBuffer(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native @Cast("sd::Pointer") Pointer dbSpecialBuffer(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbExpandBuffer(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer, @Cast("sd::LongType") long elements);
public native void dbAllocatePrimaryBuffer(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbAllocateSpecialBuffer(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbSetPrimaryBuffer(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer, @Cast("sd::Pointer") Pointer primaryBuffer, @Cast("sd::LongType") long numBytes);
public native void dbSetSpecialBuffer(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer, @Cast("sd::Pointer") Pointer specialBuffer, @Cast("sd::LongType") long numBytes);
public native void dbSyncToSpecial(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbSyncToPrimary(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native int dbLocality(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native int dbDeviceId(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbSetDeviceId(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer, int deviceId);
public native void dbTickHostRead(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbTickHostWrite(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbTickDeviceRead(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbTickDeviceWrite(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbClose(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void deleteDataBuffer(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer);
public native void dbExpand(org.nd4j.nativeblas.OpaqueDataBuffer dataBuffer, @Cast("sd::LongType") long elements);

public native int binaryLevel();
public native int optimalLevel();

public native @Cast("bool") boolean isMinimalRequirementsMet();
public native @Cast("bool") boolean isOptimalRequirementsMet();

public native void setVedaDeviceLibFolder(@StdString BytePointer path);
public native void setVedaDeviceLibFolder(@StdString String path);

// #endif  // NATIVEOPERATIONS_NATIVEOPS_H


// Parsed from memory/ExternalWorkspace.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef LIBND4J_EXTERNALWORKSPACE_H
// #define LIBND4J_EXTERNALWORKSPACE_H
// #include 
@Namespace("sd::memory") @NoOffset public static class ExternalWorkspace extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ExternalWorkspace(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ExternalWorkspace(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ExternalWorkspace position(long position) {
        return (ExternalWorkspace)super.position(position);
    }
    @Override public ExternalWorkspace getPointer(long i) {
        return new ExternalWorkspace((Pointer)this).offsetAddress(i);
    }

  public ExternalWorkspace() { super((Pointer)null); allocate(); }
  private native void allocate();

  public ExternalWorkspace(@Cast("sd::Pointer") Pointer ptrH, @Cast("sd::LongType") long sizeH, @Cast("sd::Pointer") Pointer ptrD, @Cast("sd::LongType") long sizeD) { super((Pointer)null); allocate(ptrH, sizeH, ptrD, sizeD); }
  private native void allocate(@Cast("sd::Pointer") Pointer ptrH, @Cast("sd::LongType") long sizeH, @Cast("sd::Pointer") Pointer ptrD, @Cast("sd::LongType") long sizeD);

  public native Pointer pointerHost();
  public native Pointer pointerDevice();

  public native @Cast("sd::LongType") long sizeHost();
  public native @Cast("sd::LongType") long sizeDevice();
}
  // namespace memory
  // namespace sd

// #endif


// Parsed from memory/Workspace.h

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

//
// This class implements Workspace functionality in c++
//
//
// @author [email protected]
//

// #ifndef LIBND4J_WORKSPACE_H
// #define LIBND4J_WORKSPACE_H

// #include 
// #include 
// #include 
// #include 

// #include 
// #include 
// #include 

@Namespace("sd::memory") @NoOffset public static class Workspace extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public Workspace(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public Workspace(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public Workspace position(long position) {
        return (Workspace)super.position(position);
    }
    @Override public Workspace getPointer(long i) {
        return new Workspace((Pointer)this).offsetAddress(i);
    }

  public Workspace(ExternalWorkspace external) { super((Pointer)null); allocate(external); }
  private native void allocate(ExternalWorkspace external);
  public Workspace(@Cast("sd::LongType") long initialSize/*=0L*/, @Cast("sd::LongType") long secondaryBytes/*=0L*/) { super((Pointer)null); allocate(initialSize, secondaryBytes); }
  private native void allocate(@Cast("sd::LongType") long initialSize/*=0L*/, @Cast("sd::LongType") long secondaryBytes/*=0L*/);
  public Workspace() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native @Cast("sd::LongType") long getAllocatedSize();
  public native @Cast("sd::LongType") long getCurrentSize();
  public native @Cast("sd::LongType") long getCurrentOffset();
  public native @Cast("sd::LongType") long getSpilledSize();
  public native @Cast("sd::LongType") long getUsedSize();

  public native @Cast("sd::LongType") long getAllocatedSecondarySize();
  public native @Cast("sd::LongType") long getCurrentSecondarySize();
  public native @Cast("sd::LongType") long getCurrentSecondaryOffset();
  public native @Cast("sd::LongType") long getSpilledSecondarySize();
  public native @Cast("sd::LongType") long getUsedSecondarySize();

  public native void expandBy(@Cast("sd::LongType") long primaryBytes, @Cast("sd::LongType") long secondaryBytes/*=0L*/);
  public native void expandBy(@Cast("sd::LongType") long primaryBytes);
  public native void expandTo(@Cast("sd::LongType") long primaryBytes, @Cast("sd::LongType") long secondaryBytes/*=0L*/);
  public native void expandTo(@Cast("sd::LongType") long primaryBytes);

  //            bool resizeSupported();

  public native Pointer allocateBytes(@Cast("sd::LongType") long numBytes);
  public native Pointer allocateBytes(@Cast("sd::memory::MemoryType") int type, @Cast("sd::LongType") long numBytes);

  public native void scopeIn();
  public native void scopeOut();

  /*
   * This method creates NEW workspace of the same memory size and returns pointer to it
   */
  public native Workspace clone();
}
  // namespace memory
  // namespace sd

// #endif  // LIBND4J_WORKSPACE_H


// Parsed from indexing/NDIndex.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef LIBND4J_NDINDEX_H
// #define LIBND4J_NDINDEX_H

// #include 

// #include 
@Namespace("sd") @NoOffset public static class NDIndex extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public NDIndex(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public NDIndex(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public NDIndex position(long position) {
        return (NDIndex)super.position(position);
    }
    @Override public NDIndex getPointer(long i) {
        return new NDIndex((Pointer)this).offsetAddress(i);
    }

  public NDIndex() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native @Cast("bool") boolean isAll();
  public native @Cast("bool") boolean isPoint();
  public native @Cast("bool") boolean isInterval();

  public native @Cast("sd::LongType*") @StdVector LongPointer getIndices();
  public native @Cast("sd::LongType") long stride();

  public native NDIndex all();
  public native NDIndex point(@Cast("sd::LongType") long pt);
  public native NDIndex interval(@Cast("sd::LongType") long start, @Cast("sd::LongType") long end, @Cast("sd::LongType") long stride/*=1*/);
  public native NDIndex interval(@Cast("sd::LongType") long start, @Cast("sd::LongType") long end);
}

@Namespace("sd") public static class NDIndexAll extends NDIndex {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public NDIndexAll(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public NDIndexAll(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public NDIndexAll position(long position) {
        return (NDIndexAll)super.position(position);
    }
    @Override public NDIndexAll getPointer(long i) {
        return new NDIndexAll((Pointer)this).offsetAddress(i);
    }

  public NDIndexAll() { super((Pointer)null); allocate(); }
  private native void allocate();
  public native @Cast("bool") boolean isInterval();
}

@Namespace("sd") public static class NDIndexPoint extends NDIndex {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public NDIndexPoint(Pointer p) { super(p); }

  public NDIndexPoint(@Cast("sd::LongType") long point) { super((Pointer)null); allocate(point); }
  private native void allocate(@Cast("sd::LongType") long point);
  public native @Cast("bool") boolean isInterval();
}

@Namespace("sd") public static class NDIndexInterval extends NDIndex {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public NDIndexInterval(Pointer p) { super(p); }

  public NDIndexInterval(@Cast("sd::LongType") long start, @Cast("sd::LongType") long end, @Cast("sd::LongType") long stride/*=1*/) { super((Pointer)null); allocate(start, end, stride); }
  private native void allocate(@Cast("sd::LongType") long start, @Cast("sd::LongType") long end, @Cast("sd::LongType") long stride/*=1*/);
  public NDIndexInterval(@Cast("sd::LongType") long start, @Cast("sd::LongType") long end) { super((Pointer)null); allocate(start, end); }
  private native void allocate(@Cast("sd::LongType") long start, @Cast("sd::LongType") long end);
  public native @Cast("bool") boolean isInterval();
}
  // namespace sd

// #endif  // LIBND4J_NDINDEX_H


// Parsed from indexing/IndicesList.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef LIBND4J_INDICESLIST_H
// #define LIBND4J_INDICESLIST_H
// #include 

// #include "NDIndex.h"
@Namespace("sd") @NoOffset public static class IndicesList extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public IndicesList(Pointer p) { super(p); }


  public native int size();
  public native NDIndex at(int idx);
  public native void push_back(NDIndex idx);
  public native @Cast("bool") boolean isScalar();
}
  // namespace sd
// #endif  // LIBND4J_INDICESLIST_H


// Parsed from graph/VariableType.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef ND4J_VARIABLE_TYPE_H
// #define ND4J_VARIABLE_TYPE_H
/** enum sd::graph::VariableType */
public static final int
  NDARRAY = 0,
  ARRAY_LIST = 1,
  FLOW = 2,
  CONSTANT = 3,
  PLACEHOLDER = 4;

  // namespace sd

// #endif


// Parsed from graph/ArgumentsList.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 24.01.18.
//

// #ifndef LIBND4J_INPUTLIST_H
// #define LIBND4J_INPUTLIST_H

// #include 
// #include 
// #include 

// #include 
@Namespace("sd::graph") @NoOffset public static class ArgumentsList extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ArgumentsList(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ArgumentsList(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ArgumentsList position(long position) {
        return (ArgumentsList)super.position(position);
    }
    @Override public ArgumentsList getPointer(long i) {
        return new ArgumentsList((Pointer)this).offsetAddress(i);
    }

  public ArgumentsList() { super((Pointer)null); allocate(); }
  private native void allocate();

  /**
   * This method returns number of argument pairs available
   *
   * @return
   */
  public native int size();

  /**
   * This method returns Pair at specified index
   *
   * @param index
   * @return
   */
  public native @ByRef Pair at(int index);
}
  // namespace graph
  // namespace sd

// #endif  // LIBND4J_INPUTLIST_H


// Parsed from types/pair.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 24.01.18.
//

// #ifndef LIBND4J_PAIR_H
// #define LIBND4J_PAIR_H
// #include 
@Namespace("sd") @NoOffset public static class Pair extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public Pair(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public Pair(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public Pair position(long position) {
        return (Pair)super.position(position);
    }
    @Override public Pair getPointer(long i) {
        return new Pair((Pointer)this).offsetAddress(i);
    }

  public Pair(int first/*=0*/, int second/*=0*/) { super((Pointer)null); allocate(first, second); }
  private native void allocate(int first/*=0*/, int second/*=0*/);
  public Pair() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native int first();
  public native int second();
}
  // namespace sd

// #endif  // LIBND4J_PAIR_H


// Parsed from array/NDArray.h

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

// #ifndef NDARRAY_H
// #define NDARRAY_H

// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 

// #include 
// #include 
// #include 
// #include 

@Namespace("sd") public native @ByVal NDArray mmul(@Const @ByRef NDArray arg0, @Const @ByRef NDArray arg1);

@Namespace("sd") @NoOffset public static class NDArray extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public NDArray(Pointer p) { super(p); }

  public NDArray() { super((Pointer)null); allocate(); }
  private native void allocate();

  /**
   *  do not allocate memory, memory for array is passed from outside
   */
// #ifndef __JAVACPP_HACK__

// #endif

  /**
   *  do not allocate memory, memory for array is passed from outside
   */
  public NDArray(Pointer buffer, @Cast("sd::LongType*") LongPointer shapeInfo, LaunchContext context/*=sd::LaunchContext::defaultContext()*/,
            @Cast("bool") boolean isBuffAlloc/*=false*/) { super((Pointer)null); allocate(buffer, shapeInfo, context, isBuffAlloc); }
  private native void allocate(Pointer buffer, @Cast("sd::LongType*") LongPointer shapeInfo, LaunchContext context/*=sd::LaunchContext::defaultContext()*/,
            @Cast("bool") boolean isBuffAlloc/*=false*/);
  public NDArray(Pointer buffer, @Cast("sd::LongType*") LongPointer shapeInfo) { super((Pointer)null); allocate(buffer, shapeInfo); }
  private native void allocate(Pointer buffer, @Cast("sd::LongType*") LongPointer shapeInfo);
  public NDArray(Pointer buffer, @Cast("sd::LongType*") LongBuffer shapeInfo, LaunchContext context/*=sd::LaunchContext::defaultContext()*/,
            @Cast("bool") boolean isBuffAlloc/*=false*/) { super((Pointer)null); allocate(buffer, shapeInfo, context, isBuffAlloc); }
  private native void allocate(Pointer buffer, @Cast("sd::LongType*") LongBuffer shapeInfo, LaunchContext context/*=sd::LaunchContext::defaultContext()*/,
            @Cast("bool") boolean isBuffAlloc/*=false*/);
  public NDArray(Pointer buffer, @Cast("sd::LongType*") LongBuffer shapeInfo) { super((Pointer)null); allocate(buffer, shapeInfo); }
  private native void allocate(Pointer buffer, @Cast("sd::LongType*") LongBuffer shapeInfo);
  public NDArray(Pointer buffer, @Cast("sd::LongType*") long[] shapeInfo, LaunchContext context/*=sd::LaunchContext::defaultContext()*/,
            @Cast("bool") boolean isBuffAlloc/*=false*/) { super((Pointer)null); allocate(buffer, shapeInfo, context, isBuffAlloc); }
  private native void allocate(Pointer buffer, @Cast("sd::LongType*") long[] shapeInfo, LaunchContext context/*=sd::LaunchContext::defaultContext()*/,
            @Cast("bool") boolean isBuffAlloc/*=false*/);
  public NDArray(Pointer buffer, @Cast("sd::LongType*") long[] shapeInfo) { super((Pointer)null); allocate(buffer, shapeInfo); }
  private native void allocate(Pointer buffer, @Cast("sd::LongType*") long[] shapeInfo);

  /**
   *  do not allocate memory, memory for array is passed from outside
   *  we suppose the content of both (device and host) buffers is identical
   */
  public NDArray(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") LongPointer shapeInfo,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean isBuffAlloc/*=false*/,
            @Cast("bool") boolean isBuffDAlloc/*=false*/) { super((Pointer)null); allocate(buffer, bufferD, shapeInfo, context, isBuffAlloc, isBuffDAlloc); }
  private native void allocate(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") LongPointer shapeInfo,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean isBuffAlloc/*=false*/,
            @Cast("bool") boolean isBuffDAlloc/*=false*/);
  public NDArray(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") LongPointer shapeInfo) { super((Pointer)null); allocate(buffer, bufferD, shapeInfo); }
  private native void allocate(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") LongPointer shapeInfo);
  public NDArray(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") LongBuffer shapeInfo,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean isBuffAlloc/*=false*/,
            @Cast("bool") boolean isBuffDAlloc/*=false*/) { super((Pointer)null); allocate(buffer, bufferD, shapeInfo, context, isBuffAlloc, isBuffDAlloc); }
  private native void allocate(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") LongBuffer shapeInfo,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean isBuffAlloc/*=false*/,
            @Cast("bool") boolean isBuffDAlloc/*=false*/);
  public NDArray(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") LongBuffer shapeInfo) { super((Pointer)null); allocate(buffer, bufferD, shapeInfo); }
  private native void allocate(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") LongBuffer shapeInfo);
  public NDArray(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") long[] shapeInfo,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean isBuffAlloc/*=false*/,
            @Cast("bool") boolean isBuffDAlloc/*=false*/) { super((Pointer)null); allocate(buffer, bufferD, shapeInfo, context, isBuffAlloc, isBuffDAlloc); }
  private native void allocate(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") long[] shapeInfo,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean isBuffAlloc/*=false*/,
            @Cast("bool") boolean isBuffDAlloc/*=false*/);
  public NDArray(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") long[] shapeInfo) { super((Pointer)null); allocate(buffer, bufferD, shapeInfo); }
  private native void allocate(Pointer buffer, Pointer bufferD, @Cast("const sd::LongType*") long[] shapeInfo);

  /**
   *  copy constructor
   */
  public NDArray(@Const @ByRef NDArray other) { super((Pointer)null); allocate(other); }
  private native void allocate(@Const @ByRef NDArray other);

  /**
   *  move constructor
   */

  /**
   *  constructor, create array stored at given workspace
   */
  public NDArray(LaunchContext context) { super((Pointer)null); allocate(context); }
  private native void allocate(LaunchContext context);

  /**
   *  constructor creates new NDArray using shape information from "shapeInfo", set all elements in new array to zeros,
   * if copyStrides is true then use stride values from "shapeInfo", else calculate strides independently
   */
  public NDArray(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/) { super((Pointer)null); allocate(shapeInfo, copyStrides, context, nullify); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/);
  public NDArray(@Cast("const sd::LongType*") LongPointer shapeInfo) { super((Pointer)null); allocate(shapeInfo); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo);
  public NDArray(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/) { super((Pointer)null); allocate(shapeInfo, copyStrides, context, nullify); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/);
  public NDArray(@Cast("const sd::LongType*") LongBuffer shapeInfo) { super((Pointer)null); allocate(shapeInfo); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo);
  public NDArray(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/) { super((Pointer)null); allocate(shapeInfo, copyStrides, context, nullify); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/);
  public NDArray(@Cast("const sd::LongType*") long[] shapeInfo) { super((Pointer)null); allocate(shapeInfo); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo);

  /**
   *  constructor creates new NDArray using shape information from "shapeInfo", set all elements in new array to be
   * zeros, if copyStrides is true then use stride values from "shapeInfo", else calculate strides independently set
   * dtype as array type
   */
  public NDArray(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("sd::DataType") int dtype, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/) { super((Pointer)null); allocate(shapeInfo, dtype, copyStrides, context, nullify); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("sd::DataType") int dtype, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/);
  public NDArray(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("sd::DataType") int dtype) { super((Pointer)null); allocate(shapeInfo, dtype); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("sd::DataType") int dtype);
  public NDArray(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("sd::DataType") int dtype, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/) { super((Pointer)null); allocate(shapeInfo, dtype, copyStrides, context, nullify); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("sd::DataType") int dtype, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/);
  public NDArray(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("sd::DataType") int dtype) { super((Pointer)null); allocate(shapeInfo, dtype); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("sd::DataType") int dtype);
  public NDArray(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("sd::DataType") int dtype, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/) { super((Pointer)null); allocate(shapeInfo, dtype, copyStrides, context, nullify); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("sd::DataType") int dtype, @Cast("bool") boolean copyStrides/*=false*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean nullify/*=true*/);
  public NDArray(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("sd::DataType") int dtype) { super((Pointer)null); allocate(shapeInfo, dtype); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("sd::DataType") int dtype);

  /**
   *  this constructor creates new array using shape information contained in vector argument
   */
  public NDArray(char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/) { super((Pointer)null); allocate(order, shape, dtype, context); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector LongPointer shape) { super((Pointer)null); allocate(order, shape); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector LongPointer shape);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/) { super((Pointer)null); allocate(order, shape, dtype, context); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector LongBuffer shape) { super((Pointer)null); allocate(order, shape); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector LongBuffer shape);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/) { super((Pointer)null); allocate(order, shape, dtype, context); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector long[] shape) { super((Pointer)null); allocate(order, shape); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector long[] shape);

  /**
   * This constructor creates new array with elements copied from data and using shape information stored in shape,
   * elements from data will be casted to dtype
   */
  public NDArray(char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @StdVector DoublePointer data,
            @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/, LaunchContext context/*=sd::LaunchContext::defaultContext()*/) { super((Pointer)null); allocate(order, shape, data, dtype, context); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @StdVector DoublePointer data,
            @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/, LaunchContext context/*=sd::LaunchContext::defaultContext()*/);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @StdVector DoublePointer data) { super((Pointer)null); allocate(order, shape, data); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @StdVector DoublePointer data);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @StdVector DoubleBuffer data,
            @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/, LaunchContext context/*=sd::LaunchContext::defaultContext()*/) { super((Pointer)null); allocate(order, shape, data, dtype, context); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @StdVector DoubleBuffer data,
            @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/, LaunchContext context/*=sd::LaunchContext::defaultContext()*/);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @StdVector DoubleBuffer data) { super((Pointer)null); allocate(order, shape, data); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @StdVector DoubleBuffer data);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector long[] shape, @StdVector double[] data,
            @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/, LaunchContext context/*=sd::LaunchContext::defaultContext()*/) { super((Pointer)null); allocate(order, shape, data, dtype, context); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector long[] shape, @StdVector double[] data,
            @Cast("sd::DataType") int dtype/*=sd::DOUBLE*/, LaunchContext context/*=sd::LaunchContext::defaultContext()*/);
  public NDArray(char order, @Cast("sd::LongType*") @StdVector long[] shape, @StdVector double[] data) { super((Pointer)null); allocate(order, shape, data); }
  private native void allocate(char order, @Cast("sd::LongType*") @StdVector long[] shape, @StdVector double[] data);

  /**
   *  this constructor creates new array using given buffer (without memory allocation) and shape information stored in
   * shape
   */
  public NDArray(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("sd::DataType") int dtype,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("const bool") boolean isBuffAlloc/*=false*/) { super((Pointer)null); allocate(buffer, order, shape, dtype, context, isBuffAlloc); }
  private native void allocate(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("sd::DataType") int dtype,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("const bool") boolean isBuffAlloc/*=false*/);
  public NDArray(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("sd::DataType") int dtype) { super((Pointer)null); allocate(buffer, order, shape, dtype); }
  private native void allocate(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("sd::DataType") int dtype);
  public NDArray(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("sd::DataType") int dtype,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("const bool") boolean isBuffAlloc/*=false*/) { super((Pointer)null); allocate(buffer, order, shape, dtype, context, isBuffAlloc); }
  private native void allocate(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("sd::DataType") int dtype,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("const bool") boolean isBuffAlloc/*=false*/);
  public NDArray(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("sd::DataType") int dtype) { super((Pointer)null); allocate(buffer, order, shape, dtype); }
  private native void allocate(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("sd::DataType") int dtype);
  public NDArray(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("sd::DataType") int dtype,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("const bool") boolean isBuffAlloc/*=false*/) { super((Pointer)null); allocate(buffer, order, shape, dtype, context, isBuffAlloc); }
  private native void allocate(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("sd::DataType") int dtype,
            LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("const bool") boolean isBuffAlloc/*=false*/);
  public NDArray(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("sd::DataType") int dtype) { super((Pointer)null); allocate(buffer, order, shape, dtype); }
  private native void allocate(Pointer buffer, char order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("sd::DataType") int dtype);

  /**
   * This method returns new array with the same shape & data type
   * @return
   */
  public native @ByVal NDArray like();

  /**
   * This method returns new uninitialized array with the same shape & data type
   * @return
   */
  public native @ByVal NDArray ulike();

  /**
   *  this constructor creates new NDArray with shape matching "other" array,
   *  doesn't copy "other" elements into new array !!!
   */
  public NDArray(@Const NDArray other, @Cast("bool") boolean copyStrides/*=false*/,
                     LaunchContext context/*=sd::LaunchContext::defaultContext()*/) { super((Pointer)null); allocate(other, copyStrides, context); }
  private native void allocate(@Const NDArray other, @Cast("bool") boolean copyStrides/*=false*/,
                     LaunchContext context/*=sd::LaunchContext::defaultContext()*/);

  /**
   *  this constructor creates scalar(and set its value = 0) or empty array depending on bool argument isScalar
   */
  public NDArray(@Cast("sd::DataType") int dtype, LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean isScalar/*=true*/) { super((Pointer)null); allocate(dtype, context, isScalar); }
  private native void allocate(@Cast("sd::DataType") int dtype, LaunchContext context/*=sd::LaunchContext::defaultContext()*/, @Cast("bool") boolean isScalar/*=true*/);
  public NDArray(@Cast("sd::DataType") int dtype) { super((Pointer)null); allocate(dtype); }
  private native void allocate(@Cast("sd::DataType") int dtype);

  /**
   * This method blocks until asynchronous operation finishes
   */
  public native void synchronize(@Cast("char*") String msg);
  public native void synchronize(@Cast("char*") BytePointer msg);

  /**
   * This method allows to set _isAttached flag
   * @param reallyAttached
   */
  public native void setAttached(@Cast("bool") boolean reallyAttached);

  public native void tickWriteHost();
  public native void tickWriteDevice();
  public native void tickReadHost();
  public native void tickReadDevice();
  public native void tickBothActual();
  public native @Cast("bool") boolean isActualOnHostSide();
  public native @Cast("bool") boolean isActualOnDeviceSide();
  public native void makeBothBuffersActual();

  public native void syncToHost();
  public native void syncToDevice();
  public native void syncShape();


  /**
   * This method can be used on architectures that use special buffers
   * @param writeList
   * @param readList
   */
  public native void registerSpecialUse(@Const @ByRef ConstNDArrayVector writeList,
                                   @Const @ByRef(nullValue = "std::vector{}") ConstNDArrayVector readList);
  public native void registerSpecialUse(@Const @ByRef ConstNDArrayVector writeList);
  public native void prepareSpecialUse(@Const @ByRef ConstNDArrayVector writeList,
                                  @Const @ByRef(nullValue = "std::vector{}") ConstNDArrayVector readList, @Cast("bool") boolean synchronizeWritables/*=false*/);
  public native void prepareSpecialUse(@Const @ByRef ConstNDArrayVector writeList);

  public native void registerPrimaryUse(@Const @ByRef ConstNDArrayVector writeList,
                                   @Const @ByRef(nullValue = "std::vector{}") ConstNDArrayVector readList);
  public native void registerPrimaryUse(@Const @ByRef ConstNDArrayVector writeList);
  public native void preparePrimaryUse(@Const @ByRef ConstNDArrayVector writeList,
                                  @Const @ByRef(nullValue = "std::vector{}") ConstNDArrayVector readList, @Cast("bool") boolean synchronizeWritables/*=false*/);
  public native void preparePrimaryUse(@Const @ByRef ConstNDArrayVector writeList);

// #ifndef __JAVACPP_HACK__
// #if defined(HAVE_VEDA)
//   static void registerVedaUse(const std::vector &writeList,
//                                  const std::vector &readList = {});
//   static void prepareVedaUse(const std::vector &writeList,
//                                 const std::vector &readList = {}, bool synchronizeWritables = false);

// #endif
// #endif
  /**
   * This method returns buffer pointer offset by given number of elements, wrt own data type
   * @param offset
   * @return
   */
  public native Pointer bufferWithOffset(@Cast("sd::LongType") long offset);
  public native Pointer specialBufferWithOffset(@Cast("sd::LongType") long offset);
  /**
   *  copy assignment operator
   *  in particular, when _dataType != other._dataType and both shapes are the same, there will be allocation of new
   * _buffer and _dataType acquires other._dataType
   */
  public native @ByRef @Name("operator =") NDArray put(@Const @ByRef NDArray other);

  /**
   *  move assignment operator
   */

  /**
   *  assignment operator, assigns the same scalar to all array elements
   */

  /**
   *   operators for memory allocation and deletion
   */
  public native @Name("operator new") Pointer _new(@Cast("size_t") long i);
  public native @Name("operator delete") void _delete(Pointer p);

  public native void setContext(LaunchContext context);

  /**
   *  create a new array by replicating current array by repeats times along given dimension
   *  axis - axis along which to repeat elements
   *  repeats - number of repetitions
   */
  public native @ByVal NDArray repeat(int axis, @StdVector IntPointer repeats);
  public native @ByVal NDArray repeat(int axis, @StdVector IntBuffer repeats);
  public native @ByVal NDArray repeat(int axis, @StdVector int[] repeats);

  /**
   * This method fills this array with zeros
   */
  public native void nullify();

  /**
   * This method returns quantized copy of given array
   *
   * @param array
   * @return
   */
  public native @ByVal NDArray quantize(@Const @ByRef NDArray array);

  /**
   *  fill target array by repeating current array
   *  axis - axis along which to repeat elements
   *  repeats - vector containing numbers of repetition for elements at given axis
   */
  public native void repeat(int axis, @StdVector IntPointer repeats, @ByRef NDArray target);
  public native void repeat(int axis, @StdVector IntBuffer repeats, @ByRef NDArray target);
  public native void repeat(int axis, @StdVector int[] repeats, @ByRef NDArray target);

  /**
   *  creates array which points on certain sub-range of this array, sub-range is defined by given indices
   */
  
  
  

  /**
   *  cast array elements to given dtype
   */
  public native @ByVal NDArray cast(@Cast("sd::DataType") int dtype);

  public native void cast(@ByRef NDArray target, @Cast("sd::DataType") int dtype);

  /**
   *   returns _context
   */
  public native LaunchContext getContext();

// #ifndef __JAVACPP_HACK__
// #endif

  /**
   *   returns host buffer
   */
  public native Pointer buffer();

  /**
   *   returns buffer offset (offset is the same for host and device buffers)
   */
  public native @Cast("sd::LongType") long bufferOffset();

  /**
   *  checks if array has padded buffer
   */
  public native @Cast("bool") boolean hasPaddedBuffer();

  /**
   *  if _bufferD==nullptr return _buffer, else return _bufferD
   */
  public native Pointer specialBuffer();

  /**
   *   returns device buffer if compilation is for cuda case, otherwise returns host buffer
   */
  public native Pointer platformBuffer();

  /**
   *   returns _shapeInfo
   */
  public native @Cast("const sd::LongType*") LongPointer shapeInfo();

  /**
   * Returns True if it's legally empty NDArray, or false otherwise
   * @return
   */
  public native @Cast("bool") boolean isEmpty();

  /**
   *  if _shapeInfoD==nullptr return _shapeInfo, else return _shapeInfoD
   */
  public native @Cast("const sd::LongType*") LongPointer specialShapeInfo();

  public native @Cast("const sd::LongType*") LongPointer platformShapeInfo();

  /**
   *  permutes (in-place) the dimensions in array according to "dimensions" array
   */
  public native @Cast("bool") boolean permutei(@StdVector IntPointer dimensions);
  public native @Cast("bool") boolean permutei(@StdVector IntBuffer dimensions);
  public native @Cast("bool") boolean permutei(@StdVector int[] dimensions);
  public native @Cast("bool") boolean permutei(@Const IntPointer dimensions, int rank);
  public native @Cast("bool") boolean permutei(@Const IntBuffer dimensions, int rank);
  public native @Cast("bool") boolean permutei(@Const int[] dimensions, int rank);
  public native @Cast("bool") boolean permutei(@Cast("sd::LongType*") @StdVector LongPointer dimensions);
  public native @Cast("bool") boolean permutei(@Cast("sd::LongType*") @StdVector LongBuffer dimensions);
  public native @Cast("bool") boolean permutei(@Cast("sd::LongType*") @StdVector long[] dimensions);
  public native @Cast("bool") boolean permutei(@Cast("const sd::LongType*") LongPointer dimensions, int rank);
  public native @Cast("bool") boolean permutei(@Cast("const sd::LongType*") LongBuffer dimensions, int rank);
  public native @Cast("bool") boolean permutei(@Cast("const sd::LongType*") long[] dimensions, int rank);

  public native @Cast("bool") boolean isFinite();
  public native @Cast("bool") boolean hasNaNs();
  public native @Cast("bool") boolean hasInfs();

  public native void copyBuffersContinuouslyFrom(@Const @ByRef NDArray other, @Cast("size_t") long sizeToCopyInBytes/*=0*/, @Cast("sd::LongType") long offsetThis/*=0*/,
                                     @Cast("sd::LongType") long offsetOther/*=0*/);
  public native void copyBuffersContinuouslyFrom(@Const @ByRef NDArray other);

  /**
   *  permutes the dimensions in array according to "dimensions" array, new array points on _buffer of this array
   */
  public native @ByVal NDArray permute(@StdVector IntPointer dimensions);
  public native @ByVal NDArray permute(@StdVector IntBuffer dimensions);
  public native @ByVal NDArray permute(@StdVector int[] dimensions);
  public native @ByVal NDArray permute(@Const IntPointer dimensions, int rank);
  public native @ByVal NDArray permute(@Const IntBuffer dimensions, int rank);
  public native @ByVal NDArray permute(@Const int[] dimensions, int rank);
  
  
  

  public native void permute(@Const IntPointer dimensions, int rank, @ByRef NDArray target);
  public native void permute(@Const IntBuffer dimensions, int rank, @ByRef NDArray target);
  public native void permute(@Const int[] dimensions, int rank, @ByRef NDArray target);
  public native void permute(@StdVector IntPointer dimensions, @ByRef NDArray target);
  public native void permute(@StdVector IntBuffer dimensions, @ByRef NDArray target);
  public native void permute(@StdVector int[] dimensions, @ByRef NDArray target);
  public native @ByVal NDArray permute(@Cast("sd::LongType*") @StdVector LongPointer dimensions);
  public native @ByVal NDArray permute(@Cast("sd::LongType*") @StdVector LongBuffer dimensions);
  public native @ByVal NDArray permute(@Cast("sd::LongType*") @StdVector long[] dimensions);
  public native @ByVal NDArray permute(@Cast("const sd::LongType*") LongPointer dimensions, int rank);
  public native @ByVal NDArray permute(@Cast("const sd::LongType*") LongBuffer dimensions, int rank);
  public native @ByVal NDArray permute(@Cast("const sd::LongType*") long[] dimensions, int rank);
  
  
  

  public native void permute(@Cast("const sd::LongType*") LongPointer dimensions, int rank, @ByRef NDArray target);
  public native void permute(@Cast("const sd::LongType*") LongBuffer dimensions, int rank, @ByRef NDArray target);
  public native void permute(@Cast("const sd::LongType*") long[] dimensions, int rank, @ByRef NDArray target);
  public native void permute(@Cast("sd::LongType*") @StdVector LongPointer dimensions, @ByRef NDArray target);
  public native void permute(@Cast("sd::LongType*") @StdVector LongBuffer dimensions, @ByRef NDArray target);
  public native void permute(@Cast("sd::LongType*") @StdVector long[] dimensions, @ByRef NDArray target);

  /**
   * This method streamlines given view or permuted array, and reallocates buffer
   */
  public native void streamline(char order/*='a'*/);
  public native void streamline();

  /**
   *  prints information about array shape
   *  msg - message to print out
   */
  public native void printShapeInfo(@Cast("char*") String msg/*=nullptr*/);
  public native void printShapeInfo();
  public native void printShapeInfo(@Cast("char*") BytePointer msg/*=nullptr*/);

  /**
   *  prints buffer elements
   *  msg - message to print out
   *  limit - number of array elements to print out
   *  sync - if true check whether host buffer is actual, if it is not then make it so
   */
  public native void printBuffer(@Cast("char*") String msg/*=nullptr*/, @Cast("sd::LongType") long _limit/*=-1*/, @Cast("const bool") boolean sync/*=true*/);
  public native void printBuffer();
  public native void printBuffer(@Cast("char*") BytePointer msg/*=nullptr*/, @Cast("sd::LongType") long _limit/*=-1*/, @Cast("const bool") boolean sync/*=true*/);

  /**
   * print element by element consequently in a way they (elements) are stored in physical memory
   */
  public native void printLinearBuffer();

  /**
   *  prints _buffer (if host = true) or _bufferD (if host = false) as it is, that is in current state without checking
   * buffer status
   */

  /**
   *  prints buffer elements, takes into account offset between elements (element-wise-stride)
   *  msg - message to print out
   *  limit - number of array elements to print out
   */
  public native void printIndexedBuffer(@Cast("char*") String msg/*=nullptr*/, @Cast("sd::LongType") long _limit/*=-1*/);
  public native void printIndexedBuffer();
  public native void printIndexedBuffer(@Cast("char*") BytePointer msg/*=nullptr*/, @Cast("sd::LongType") long _limit/*=-1*/);

  public native @StdString BytePointer asIndexedString(@Cast("sd::LongType") long _limit/*=-1*/);
  public native @StdString BytePointer asIndexedString();
  public native @StdString BytePointer asString(@Cast("sd::LongType") long _limit/*=-1*/);
  public native @StdString BytePointer asString();

  /**
   *  this method assigns values of given array to this one
   */
  public native void assign(@Const NDArray other, @Cast("bool") boolean allowParallelism/*=true*/);
  public native void assign(@Const NDArray other);

  /**
   *  this method assigns values of given array to this one
   */

  /**
   *  this method assigns given value to all elements in array
   */

  /**
   *  returns new copy of this array, optionally in different order
   */
  public native @ByVal NDArray dup(byte newOrder/*='a'*/);
  public native @ByVal NDArray dup();



  /**
   *  returns sum of all elements of array
   */
  public native @ByVal NDArray sumNumber();


  /**
   *  returns prod of all elements of array
   */
  public native @ByVal NDArray prodNumber();


  /**
   *  returns mean number of array
   */
  public native @ByVal NDArray meanNumber();

// #ifndef __JAVACPP_HACK__

// #endif

  /**
   *   apply transpose operation to the copy of this array, that is this array remains unaffected
   */
  public native @ByVal NDArray transpose();
  

  /**
   *  perform transpose operation and store result in target, this array remains unaffected
   *  target - where to store result
   */
  public native void transpose(@ByRef NDArray target);

  /**
   *  apply in-place transpose operation to this array, so this array becomes transposed
   */
  public native void transposei();

  /**
   *  returns the number of arrays pointing on specified dimension(s)
   *  dimensions - array of dimensions to point on
   */
  public native @Cast("sd::LongType") long tensorsAlongDimension(@StdVector IntPointer dimensions);
  public native @Cast("sd::LongType") long tensorsAlongDimension(@StdVector IntBuffer dimensions);
  public native @Cast("sd::LongType") long tensorsAlongDimension(@StdVector int[] dimensions);

  /**
   *  returns true if elements of two arrays are equal to within given epsilon value
   *  other - input array to compare
   *  eps - epsilon, this value defines the precision of elements comparison
   */
  public native @Cast("bool") boolean equalsTo(@Const NDArray other, double eps/*=1e-5*/);
  public native @Cast("bool") boolean equalsTo(@Const NDArray other);

  /**
   *  add given row vector to all rows of this array
   *  row - row vector to add
   */
  public native void addiRowVector(@Const @ByRef NDArray row);

  /**
   *  add given row vector to all rows of this array, store result in target
   *  row - row vector to add
   *  target - where to store result
   */
  public native void addRowVector(@Const @ByRef NDArray row, @ByRef NDArray target);

  /**
   *  subtract given row vector from all rows of this array, store result in target
   *  row - row vector to subtract
   *  target - where to store result
   */
  public native void subRowVector(@Const @ByRef NDArray row, @ByRef NDArray target);

  /**
   *  multiply all rows of this array on given row vector, store result in target
   *  row - row vector to multiply on
   *  target - where to store result
   */
  public native void mulRowVector(@Const @ByRef NDArray row, @ByRef NDArray target);

  /**
   *  divide all rows of this array on given row vector, store result in target
   *  row - row vector to divide on
   *  target - where to store result
   */
  public native void divRowVector(@Const @ByRef NDArray row, @ByRef NDArray target);

  /**
   *  add given column vector to all columns of this array, store result in target
   *  column - column vector to add
   *  target - where to store result
   */
  public native void addColumnVector(@Const @ByRef NDArray column, @ByRef NDArray target);

  /**
   *  add given column vector to all columns of this array, this array becomes affected (in-place operation)
   *  column - column vector to add
   */
  public native void addiColumnVector(@Const @ByRef NDArray column);

  /**
   *  multiply all columns of this array on given column vector, this array becomes affected (in-place operation)
   *  column - column vector to multiply on
   */
  public native void muliColumnVector(@Const @ByRef NDArray column);

  /**
   *  returns number of bytes used by _buffer & _shapeInfo
   */
  public native @Cast("sd::LongType") long memoryFootprint();

  /**
   *  these methods suited for FlatBuffers use
   */
  public native @Cast("sd::LongType*") @StdVector LongPointer getShapeAsVector();
  public native @StdVector IntPointer getShapeAsVectorInt();
  public native @Cast("sd::LongType*") @StdVector LongPointer getShapeInfoAsVector();
  public native @Cast("int64_t*") @StdVector LongPointer getShapeInfoAsFlatVector();
  public native @Cast("int64_t*") @StdVector LongPointer getShapeAsFlatVector();

  /**
   *  set new order and shape in case of suitable array length (in-place operation)
   *  order - order to set
   *  shape - shape to set
   *  copyToNewBuff - if true then old buffer will be copied to new buffer if last one will be allocated after reshaping
   *  if there was permute applied before or there are weird strides, then new buffer is allocated for array
   */
  public native @Cast("bool") boolean reshapei(byte order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @Cast("bool") boolean reshapei(byte order, @Cast("sd::LongType*") @StdVector LongPointer shape);
  public native @Cast("bool") boolean reshapei(byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @Cast("bool") boolean reshapei(byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape);
  public native @Cast("bool") boolean reshapei(byte order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @Cast("bool") boolean reshapei(byte order, @Cast("sd::LongType*") @StdVector long[] shape);
  public native @Cast("bool") boolean reshapei(@Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @Cast("bool") boolean reshapei(@Cast("sd::LongType*") @StdVector LongPointer shape);
  public native @Cast("bool") boolean reshapei(@Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @Cast("bool") boolean reshapei(@Cast("sd::LongType*") @StdVector LongBuffer shape);
  public native @Cast("bool") boolean reshapei(@Cast("sd::LongType*") @StdVector long[] shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @Cast("bool") boolean reshapei(@Cast("sd::LongType*") @StdVector long[] shape);

  /**
   *  creates new array with corresponding order and shape, new array will point on _buffer of this array
   *  order - order to set
   *  shape - shape to set
   *
   * if permute have been applied before or there are weird strides, then new buffer is allocated for new array
   */
  public native @ByVal NDArray reshape(byte order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @ByVal NDArray reshape(byte order, @Cast("sd::LongType*") @StdVector LongPointer shape);
  public native @ByVal NDArray reshape(byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @ByVal NDArray reshape(byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape);
  public native @ByVal NDArray reshape(byte order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("const bool") boolean copyToNewBuff/*=true*/);
  public native @ByVal NDArray reshape(byte order, @Cast("sd::LongType*") @StdVector long[] shape);
  

  /**
   *  calculate strides and set given order
   *  order - order to set
   */
  public native void updateStrides(byte order);

  /**
   *  change an array by repeating it the number of times given by reps (in-place operation)
   *  repeats - contains numbers of repetitions
   */
  public native void tilei(@Cast("sd::LongType*") @StdVector LongPointer repeats);
  public native void tilei(@Cast("sd::LongType*") @StdVector LongBuffer repeats);
  public native void tilei(@Cast("sd::LongType*") @StdVector long[] repeats);

  /**
   *  returns new array which is created by repeating of this array the number of times given by reps
   *  repeats - contains numbers of repetitions
   */
  public native @ByVal NDArray tile(@Cast("sd::LongType*") @StdVector LongPointer repeats);
  public native @ByVal NDArray tile(@Cast("sd::LongType*") @StdVector LongBuffer repeats);
  public native @ByVal NDArray tile(@Cast("sd::LongType*") @StdVector long[] repeats);

  /**
   *  change an array by repeating it the number of times given by reps (in-place operation)
   *  repeats - contains numbers of repetitions
   *  target - where to store result
   */
  public native void tile(@Cast("sd::LongType*") @StdVector LongPointer repeats, @ByRef NDArray target);
  public native void tile(@Cast("sd::LongType*") @StdVector LongBuffer repeats, @ByRef NDArray target);
  public native void tile(@Cast("sd::LongType*") @StdVector long[] repeats, @ByRef NDArray target);

  /**
   *  change an array by repeating it the number of times to acquire the new shape which is the same as target shape
   *  target - where to store result
   */
  public native void tile(@ByRef NDArray target);

  /**
   *  check whether array is identity matrix
   */
  public native @Cast("bool") boolean isIdentityMatrix();

  /**
   *  check whether array is unitary matrix
   */
  public native @Cast("bool") boolean isUnitary();

  /**
   *  operator returns subarray with buffer pointing at this->_buffer with offset defined by given intervals
   *  idx - intervals of indexes which define the subarrays to point on, idx has form {dim0Start,dim0End,
   * dim1Start,dim1End, ....} and length (2 * this->rankOf()) when (dimStart == dimEnd) then whole range will be used
   * for current dimension keepUnitiesInShape - if false then eliminate unities from resulting array shape, for example
   * {1,a,1,b} -> {a,b} isStrided - if true then idx has length (3 * this->rankOf()) and contains additional stride
   * numbers which correspond to stride between dimStart and dimEnd, so structure of idx is like
   * {dim0Start,dim0End,dim0Stride,    dim1Start,dim1End,dim1Stride, ....}
   */
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("sd::LongType*") @StdVector LongPointer idx, @Cast("const bool") boolean keepUnitiesInShape/*=false*/,
                       @Cast("const bool") boolean isStrided/*=false*/);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("sd::LongType*") @StdVector LongPointer idx);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("sd::LongType*") @StdVector LongBuffer idx, @Cast("const bool") boolean keepUnitiesInShape/*=false*/,
                       @Cast("const bool") boolean isStrided/*=false*/);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("sd::LongType*") @StdVector LongBuffer idx);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("sd::LongType*") @StdVector long[] idx, @Cast("const bool") boolean keepUnitiesInShape/*=false*/,
                       @Cast("const bool") boolean isStrided/*=false*/);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("sd::LongType*") @StdVector long[] idx);

  /**
   *  evaluates subarray with buffer pointing at this->_buffer and offset defined by given sequential index subArrIdx
   * and dimensions in dimsToExclude subArrIdx - index of current sub-array dimsToExclude - MUST BE SORTED, dimensions
   * to evaluate sub-array along, i.e. when shape is [2,3,4,5] and dimsToExclude={0,2}, then there will be 8 sub-arrays
   * with shape [3,5], and subArrIdx must be in range [0,7] if dimsToExclude is empty then idxRanges containing all
   * zeros (means whole array) will be returned. keepUnitiesInShape - if false then eliminate unities from resulting
   * array shape, for example {1,a,1,b} -> {a,b}
   */
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("const sd::LongType") long subArrIdx, @StdVector IntPointer dimsToExclude,
                       @Cast("bool") boolean keepUnitiesInShape/*=false*/);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("const sd::LongType") long subArrIdx, @StdVector IntPointer dimsToExclude);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("const sd::LongType") long subArrIdx, @StdVector IntBuffer dimsToExclude,
                       @Cast("bool") boolean keepUnitiesInShape/*=false*/);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("const sd::LongType") long subArrIdx, @StdVector IntBuffer dimsToExclude);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("const sd::LongType") long subArrIdx, @StdVector int[] dimsToExclude,
                       @Cast("bool") boolean keepUnitiesInShape/*=false*/);
  public native @ByVal @Name("operator ()") NDArray apply(@Cast("const sd::LongType") long subArrIdx, @StdVector int[] dimsToExclude);

  /**
   * processes whole set of sub-arrays
   * evaluates shapeInfo of sub-arrays (all sub-arrays have the same shapeInfo) and their buffer offsets (each sub-array
   * has its own unique offset from original this-buffer) dimsToExclude - MUST BE SORTED, dimensions to evaluate
   * sub-array along, i.e. when shape is [2,3,4,5] and dimsToExclude={0,2}, then there will be 8 sub-arrays with shape
   * [3,5] if dimsToExclude.size() = array rank it means sub-array is whole array and copy of original_shapeInfo will be
   * returned and one zero offset subArrShapeInfo    - output argument, contains shapeInfo common for all sub-arrays
   * subArrOffsets      - output argument, contains successive sub-arrays offsets from original this-buffer
   * keepUnitiesInShape - if false then eliminate unities from sub-array shapeInfo, for example {1,a,1,b} -> {a,b}
   */
  public native void getSubArrShapeAndOffsets(@StdVector IntPointer dimsToExclude, @Cast("sd::LongType*&") @ByPtrRef LongPointer subArrShapeInfo,
                                  @Cast("sd::LongType*&") @ByPtrRef LongPointer subArrOffsets, @Cast("bool") boolean keepUnitiesInShape/*=false*/);
  public native void getSubArrShapeAndOffsets(@StdVector IntPointer dimsToExclude, @Cast("sd::LongType*&") @ByPtrRef LongPointer subArrShapeInfo,
                                  @Cast("sd::LongType*&") @ByPtrRef LongPointer subArrOffsets);
  public native void getSubArrShapeAndOffsets(@StdVector IntBuffer dimsToExclude, @Cast("sd::LongType*&") @ByPtrRef LongBuffer subArrShapeInfo,
                                  @Cast("sd::LongType*&") @ByPtrRef LongBuffer subArrOffsets, @Cast("bool") boolean keepUnitiesInShape/*=false*/);
  public native void getSubArrShapeAndOffsets(@StdVector IntBuffer dimsToExclude, @Cast("sd::LongType*&") @ByPtrRef LongBuffer subArrShapeInfo,
                                  @Cast("sd::LongType*&") @ByPtrRef LongBuffer subArrOffsets);
  public native void getSubArrShapeAndOffsets(@StdVector int[] dimsToExclude, @Cast("sd::LongType*&") @ByPtrRef long[] subArrShapeInfo,
                                  @Cast("sd::LongType*&") @ByPtrRef long[] subArrOffsets, @Cast("bool") boolean keepUnitiesInShape/*=false*/);
  public native void getSubArrShapeAndOffsets(@StdVector int[] dimsToExclude, @Cast("sd::LongType*&") @ByPtrRef long[] subArrShapeInfo,
                                  @Cast("sd::LongType*&") @ByPtrRef long[] subArrOffsets);

  /**
   *  addition unary operator array += other
   *  other - input array to add
   */
  public native @Name("operator +=") void addPut(@Const @ByRef NDArray other);

  /**
   *  subtraction unary operator array -= other
   *  other - input array to add
   */
  public native @Name("operator -=") void subtractPut(@Const @ByRef NDArray other);

  /**
   *  negative operator, it changes sign of all array elements on opposite
   */
  public native @ByVal @Name("operator -") NDArray subtract();
  

  /**
   *  pairwise multiplication unary operator array *= other
   *  other - input array to multiply on
   */
  public native @Name("operator *=") void multiplyPut(@Const @ByRef NDArray other);

  /**
   *  multiplication unary operator array *= scalar
   *  scalar - input scalar to multiply on
   */

  /**
   *  pairwise division unary operator: array /= other
   *  other - input array to divide on
   */
  public native @Name("operator /=") void dividePut(@Const @ByRef NDArray other);

  /**
   *  division unary operator: array /= scalar
   *  scalar - input scalar to divide on
   */

  /**
   *  friend function which implements mathematical multiplication of two arrays
   *  left - input array
   *  right - input array
   */
  

  /**
   *  return vector containing _buffer as flat binary array
   */
  public native @StdVector BytePointer asByteVector();

  /**
   *  makes array to be identity matrix (not necessarily square), that is set all diagonal elements = 1, rest = 0
   */
  public native void setIdentity();

  /**
   *  swaps the contents of tow arrays,
   *  PLEASE NOTE: method doesn't take into account the shapes of arrays, shapes may be different except one condition:
   * arrays lengths must be the same
   */
  public native void swapUnsafe(@ByRef NDArray other);

  /**
   *  return vector with buffer which points on corresponding diagonal elements of array
   *  type - means of vector to be returned: column ('c') or row ('r')
   */
  public native @ByVal NDArray diagonal(byte type);

  /**
   * fill target matrix with given value in one or two directions from main diagonal:
   *   - down from main diagonal starting at subdiagonal number "lower" if direction = 'l' (down) or 'b' (both)
   *   - up from main diagonal starting at superdiagonal number "upper"if direction = 'u' (up) or 'b' (both)
   * direction - in what direction to fill matrix. There are 3 possible directions:
   *   'u' - fill up, mathematically this corresponds to lower triangular matrix, subdiagonal "lower" unaffected
   *   'l' - fill down, mathematically this corresponds to upper triangular matrix, superdiagonal "upper" remains
   * unaffected 'b' - fill in both directions, both "lower" and "upper" are taken into account rest of target elements
   * are equal to this array elements target and this array should have same shapes, except when this_rank = 1 (in that
   * case should be target_rank = 2)
   *
   * includeEdges handles the cases where we need to include edges (basically >= or <= 0 and edges of the triangle)
   */

  /**
   *  change an array by repeating it the number of times in order to acquire new shape equal to the input shape
   *
   *  shape  - contains new shape to broadcast array to
   *  target - optional argument, if target != nullptr the resulting array will be placed in target, in opposite case
   * tile operation is done in place
   */
  public native @ByVal NDArray tileToShape(@Cast("const sd::LongType*") LongPointer shapeInfo);
  public native @ByVal NDArray tileToShape(@Cast("const sd::LongType*") LongBuffer shapeInfo);
  public native @ByVal NDArray tileToShape(@Cast("const sd::LongType*") long[] shapeInfo);
  public native void tileToShape(@Cast("sd::LongType*") @StdVector LongPointer shape, @ByRef NDArray target);
  public native void tileToShape(@Cast("sd::LongType*") @StdVector LongBuffer shape, @ByRef NDArray target);
  public native void tileToShape(@Cast("sd::LongType*") @StdVector long[] shape, @ByRef NDArray target);
// #ifndef __JAVACPP_HACK__
// #endif

  public native @ByVal NDArray asT(@Cast("sd::DataType") int dtype);

  public native void linspace(double start);

  public native void linspace(double start, double step);

  /**
   *  calculates the trace of an array, that is sum of elements on main diagonal = sum array[i, i, i, ...]
   */
  public native double getTrace();

  public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector IntPointer indices, @StdVector IntPointer dimensions);
  public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector IntBuffer indices, @StdVector IntBuffer dimensions);
  public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector int[] indices, @StdVector int[] dimensions);

  public native @ByVal ResultSet allTensorsAlongDimension(@StdVector IntPointer dimensions);
  public native @ByVal ResultSet allTensorsAlongDimension(@StdVector IntBuffer dimensions);
  public native @ByVal ResultSet allTensorsAlongDimension(@StdVector int[] dimensions);

  public native @ByVal ResultSet allExamples();

  /**
   *  set _shapeInfo
   */
  public native void setShapeInfo(@Cast("const sd::LongType*") LongPointer shapeInfo);
  public native void setShapeInfo(@Cast("const sd::LongType*") LongBuffer shapeInfo);
  public native void setShapeInfo(@Cast("const sd::LongType*") long[] shapeInfo);
  public native void setShapeInfo(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("const sd::DataType") int dtype);
  public native void setShapeInfo(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("const sd::DataType") int dtype);
  public native void setShapeInfo(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("const sd::DataType") int dtype);
  public native void setShapeInfo(@Const @ByRef ShapeDescriptor descriptor);
  public native void setShapeInfo(@Const @ByRef ConstantShapeBuffer shapeBuffer);

  /**
   *  returns absolute offset which corresponds to given sequential index
   */
  public native @Cast("sd::LongType") long getOffset(@Cast("const sd::LongType") long i);

  /**
   *  returns reference on array element with given index
   */

  /**
   *  returns array element with given index
   *  i - element index in array
   */

  /**
   *  default destructor
   */

  /**
   *  set _shapeInfo
   */

  /**
   *  returns the value of "dim" dimension
   */
  public native @Cast("sd::LongType") long sizeAt(int dim);

  /**
   *  returns stride of "dim" dimension
   */
  public native @Cast("sd::LongType") long strideAt(int dim);

  /**
   *  returns order of array
   */
  public native char ordering();

  /**
   *  return _isView
   */
  public native @Cast("bool") boolean isView();

  /**
   *  returns shape portion of shapeInfo
   */
  public native @Cast("sd::LongType*") LongPointer shapeOf();

  /**
   *  returns strides portion of shapeInfo
   */
  public native @Cast("sd::LongType*") LongPointer stridesOf();

  /**
   *  returns rank of array
   */
  public native int rankOf();

  /**
   *  returns length of array
   */
  public native @Cast("sd::LongType") long lengthOf();

  /**
   *  returns number of rows in array
   */
  public native @Cast("sd::LongType") long rows();

  /**
   *  returns number of columns in array
   */
  public native @Cast("sd::LongType") long columns();

  /**
   *  returns size of array elements type
   */
  public native @Cast("size_t") long sizeOfT();

  /**
   *  returns element-wise-stride
   */
  public native @Cast("sd::LongType") long ews();

  // returns true if arrays have same shape
  public native @Cast("bool") boolean isSameShape(@Const NDArray other);
  public native @Cast("bool") boolean isSameShape(@Cast("sd::LongType*") @StdVector LongPointer shape);
  public native @Cast("bool") boolean isSameShape(@Cast("sd::LongType*") @StdVector LongBuffer shape);
  public native @Cast("bool") boolean isSameShape(@Cast("sd::LongType*") @StdVector long[] shape);
  public native @Cast("bool") boolean areSameShapeAndType(@Const @ByRef NDArray other);

  /**
   *  returns true if these two NDArrays have same rank, dimensions, strides, ews and order
   */
  public native @Cast("bool") boolean isSameShapeStrict(@Const @ByRef NDArray other);

  /**
   *  returns true if buffer && shapeInfo were defined (non nullptr)
   */
  public native @Cast("bool") boolean nonNull();

  /**
   *  returns array element with given index from linear buffer
   *  i - element index in array
   */

  /**
   *  returns element with given indexes from 2D array
   *  i - number of row
   *  j - number of column
   */

  /**
   *  returns element with given indexes from 3D array
   *  i - height
   *  j - width
   *  k - depth
   */

  /**
   *  returns element with given indexes from DD array
   */

  /**
   *  returns array-scalar containing element of this array with given index
   *  i - element index in array
   */
  public native @ByVal NDArray e(@Cast("const sd::LongType") long i);

  /**
   *  assigns given scalar to array element by given index, regards array buffer as linear
   *  i - element index in array
   *  value - scalar value to assign
   */

  public native void p(@Cast("const sd::LongType") long i, @Const @ByRef NDArray value);

  /**
   *  assigns given scalar to 2D array element by given indexes
   *  i - number of row
   *  j - number of row
   *  value - scalar value to assign
   */

  /**
   *  assigns given scalar to 3D array element by given indexes
   *  i - height
   *  j - width
   *  k - depth
   *  value - scalar value to assign
   */
  public native void p(@Cast("const sd::LongType") long i, @Cast("const sd::LongType") long j, @Cast("const sd::LongType") long k, @Cast("const sd::LongType") long l, @Const @ByRef NDArray value);

  /**
   *  returns true if array is 2D
   */
  public native @Cast("bool") boolean isMatrix();

  /**
   *  returns true if array is vector
   */
  public native @Cast("bool") boolean isVector();

  /**
   *  returns true if array is column vector
   */
  public native @Cast("bool") boolean isColumnVector();

  /**
   *  returns true if array is row vector
   */
  public native @Cast("bool") boolean isRowVector();

  /**
   *  returns true if all dimensions of array except one are unities, for example: [1,1,n,1], [n,1,1], [n], ...
   *  posOfNonUnityDim - one dimension with value > 1
   */
  public native @Cast("bool") boolean isCommonVector(@ByRef IntPointer posOfNonUnityDim);
  public native @Cast("bool") boolean isCommonVector(@ByRef IntBuffer posOfNonUnityDim);
  public native @Cast("bool") boolean isCommonVector(@ByRef int[] posOfNonUnityDim);

  /**
   *  returns true if array is scalar
   */
  public native @Cast("bool") boolean isScalar();

  /**
   * Returns data type of this array
   * @return
   */
  public native @Cast("sd::DataType") int dataType();

  /**
   * This method returns true if value is from Integer space
   * @return
   */
  public native @Cast("bool") boolean isZ();

  /**
   * This method returns true if array is from Real space
   * @return
   */
  public native @Cast("bool") boolean isR();

  /**
   * This method returns true if array is from Boolean space
   * @return
   */
  public native @Cast("bool") boolean isB();

  /**
   * This method returns true if array contains Complex numbers
   * @return
   */
  public native @Cast("bool") boolean isC();

  /**
   * This method returns true if array contains String
   * @return
   */
  public native @Cast("bool") boolean isS();

  public native @Cast("bool") boolean isAttached();

  public native NDArray detach();

  public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef NDArray other);

  public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef NDArray other);
  public NDArray(Pointer buffer, byte order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("sd::DataType") int dtype,
            LaunchContext context, @Cast("const bool") boolean isBuffAlloc, @Cast("const bool") boolean isView, @Cast("sd::LongType") long offset) { super((Pointer)null); allocate(buffer, order, shape, dtype, context, isBuffAlloc, isView, offset); }
  private native void allocate(Pointer buffer, byte order, @Cast("sd::LongType*") @StdVector LongPointer shape, @Cast("sd::DataType") int dtype,
            LaunchContext context, @Cast("const bool") boolean isBuffAlloc, @Cast("const bool") boolean isView, @Cast("sd::LongType") long offset);
  public NDArray(Pointer buffer, byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("sd::DataType") int dtype,
            LaunchContext context, @Cast("const bool") boolean isBuffAlloc, @Cast("const bool") boolean isView, @Cast("sd::LongType") long offset) { super((Pointer)null); allocate(buffer, order, shape, dtype, context, isBuffAlloc, isView, offset); }
  private native void allocate(Pointer buffer, byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape, @Cast("sd::DataType") int dtype,
            LaunchContext context, @Cast("const bool") boolean isBuffAlloc, @Cast("const bool") boolean isView, @Cast("sd::LongType") long offset);
  public NDArray(Pointer buffer, byte order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("sd::DataType") int dtype,
            LaunchContext context, @Cast("const bool") boolean isBuffAlloc, @Cast("const bool") boolean isView, @Cast("sd::LongType") long offset) { super((Pointer)null); allocate(buffer, order, shape, dtype, context, isBuffAlloc, isView, offset); }
  private native void allocate(Pointer buffer, byte order, @Cast("sd::LongType*") @StdVector long[] shape, @Cast("sd::DataType") int dtype,
            LaunchContext context, @Cast("const bool") boolean isBuffAlloc, @Cast("const bool") boolean isView, @Cast("sd::LongType") long offset);
// #ifndef __JAVACPP_HACK__
// #endif
}

//////////////////////////////////////////////////////////////////////////
///// IMPLEMENTATION OF INLINE METHODS /////
//////////////////////////////////////////////////////////////////////////




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


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


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


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


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


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


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


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


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


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


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



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


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


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


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


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


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


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


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


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


//////////////////////////////////////////////////////////////////////////
// still the definition of inline function must be in header file


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


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


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


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


//////////////////////////////////////////////////////////////////////////
// returns true if these two NDArrays have same _shapeInfo
// still the definition of inline function must be in header file



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


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


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


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


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


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






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


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


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


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


// #ifndef __JAVACPP_HACK__
// #endif

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


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


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


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


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


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


// #if defined(__CUDACC__)  //&& defined(BUILD_TESTS)
// for CUDA we need stil stuff inline
// #include 
// #endif

  // namespace sd

// #endif


// Parsed from array/NDArrayList.h

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

//
// This class describes collection of NDArrays
//
// @author raver119!gmail.com
//

// #ifndef NDARRAY_LIST_H
// #define NDARRAY_LIST_H
// #include 
// #include 
// #include 

// #include 
// #include 
// #include 
@Namespace("sd") @NoOffset public static class NDArrayList extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public NDArrayList(Pointer p) { super(p); }

  public NDArrayList(int height, @Cast("bool") boolean expandable/*=false*/) { super((Pointer)null); allocate(height, expandable); }
  private native void allocate(int height, @Cast("bool") boolean expandable/*=false*/);
  public NDArrayList(int height) { super((Pointer)null); allocate(height); }
  private native void allocate(int height);

  public native @Cast("sd::DataType") int dataType();

  public native NDArray remove(int idx);
  public native NDArray read(int idx);
  public native NDArray readRaw(int idx);
  public native @Cast("sd::Status") int write(int idx, NDArray array);
  public native NDArray pick(@StdVector IntPointer indices);
  public native NDArray pick(@StdVector IntBuffer indices);
  public native NDArray pick(@StdVector int[] indices);
  public native @Cast("bool") boolean isWritten(int index);

  public native @Cast("sd::LongType*") @StdVector LongPointer shape();

  public native NDArray stack();
  public native void unstack(NDArray array, int axis);

  public native @ByRef IntIntPair id();
  public native @StdString @ByRef @Cast({"char*", "std::string*"}) BytePointer name();
  // sd::memory::Workspace* workspace();
  public native LaunchContext context();
  public native NDArrayList clone();

  public native @Cast("bool") boolean equals(@ByRef NDArrayList other);

  public native int elements();
  public native int height();

  public native int counter();
}
  // namespace sd

// #endif


// Parsed from array/ResultSet.h

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

//
// This class is suited for execution results representation.
//
// PLESE NOTE: It will delete all stored NDArrays upon destructor call
//
// @author [email protected]
//

// #ifndef LIBND4J_RESULTSET_H
// #define LIBND4J_RESULTSET_H
// #include 
// #include 

// #include   // forward declaration of template class NDArray

@Namespace("sd") @NoOffset public static class ResultSet extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ResultSet(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ResultSet(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ResultSet position(long position) {
        return (ResultSet)super.position(position);
    }
    @Override public ResultSet getPointer(long i) {
        return new ResultSet((Pointer)this).offsetAddress(i);
    }

  public ResultSet() { super((Pointer)null); allocate(); }
  private native void allocate();

// #ifndef __JAVACPP_HACK__
// #endif

  public ResultSet(@Const @ByRef ResultSet other) { super((Pointer)null); allocate(other); }
  @NoException(true) private native void allocate(@Const @ByRef ResultSet other);

  public native @ByRef @Name("operator =") @NoException(true) ResultSet put(@Const @ByRef ResultSet other);

  // move constructor

  // move assignment operator

  public native int size();
  public native NDArray at(@Cast("const unsigned long") long idx);
  public native @Name("operator []") NDArray get(@Cast("const unsigned long") long idx);
  public native void push_back(NDArray array);

  public native @Cast("sd::Status") int status();
  public native void setStatus(@Cast("sd::Status") int status);
  public native void purge();
  public native void setNonRemovable();
}
  // namespace sd

// #endif  // LIBND4J_RESULTSET_H


// Parsed from graph/RandomGenerator.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef LIBND4J_GRAPH_RNG_H
// #define LIBND4J_GRAPH_RNG_H
// #include 
// #include 
// #include (WORKSPACE, LENGTH);
// #define RELEASE(VARIABLE, WORKSPACE) internal_release_host(WORKSPACE, VARIABLE);

// #define CONSTANT(SHAPE) ConstantShapeHelper::getInstance().createFromExisting(SHAPE, block.workspace())

// #define STORE_RESULT(A) this->storeResult(block, 0, A)
// #define OVERWRITE_RESULT(A) this->overwriteResult(block, 0, A)
// #define OVERWRITE_RESULT_NO_DELETE(A) this->overwriteResult(block, 0, A,false)

// #define OVERWRITE_2_RESULTS(A, B)
//   this->overwriteResult(block, 0, A);
//   this->overwriteResult(block, 1, B)
// #define STORE_2_RESULTS(A, B)
//   this->storeResult(block, 0, A);
//   this->storeResult(block, 1, B)
// #define STORE_3_RESULTS(A, B, C)
//   this->storeResult(block, 0, A);
//   this->storeResult(block, 1, B);
//   this->storeResult(block, 2, C)
// #define STORE_4_RESULTS(A, B, C, D)
//   this->storeResult(block, 0, A);
//   this->storeResult(block, 1, B);
//   this->storeResult(block, 2, C);
//   this->storeResult(block, 3, D)
// #define STORE_5_RESULTS(A, B, C, D, E)
//   this->storeResult(block, 0, A);
//   this->storeResult(block, 1, B);
//   this->storeResult(block, 2, C);
//   this->storeResult(block, 3, D);
//   this->storeResult(block, 4, E)
// #define BROADCAST_CHECK_EMPTY(X, Y, Z)
//   if (X->isEmpty() || Y->isEmpty()) {
//     if (!Z->isEmpty()) {
//       throw std::invalid_argument("Broadcast op validation failed: if x or y are empty, z must be empty");
//     }
//     return sd::Status::OK;
//   }

// #define STASH(NAME, ARRAY) block.getStash()->storeArray(block.getNodeId(), NAME, ARRAY);
// #define CHECK_STASH(NAME) block.getStash()->checkStash(block.getNodeId(), NAME);
// #define UNSTASH(NAME) block.getStash()->extractArray(block.getNodeId(), NAME);

// #define INPUT_VARIABLE(INDEX) block.array(INDEX)
// #define OUTPUT_VARIABLE(INDEX) reinterpret_cast(this->getZ(block, INDEX))
// #define OUTPUT_NULLIFIED(INDEX) reinterpret_cast(this->getNullifiedZ(block, INDEX))

// #define INPUT_LIST(INDEX) reinterpret_cast(block.getVariable(INDEX)->getNDArrayList())

// #define D_ARG(INDEX) block.getDArguments()->at(INDEX)
// #define INT_ARG(INDEX) block.getIArguments()->at(INDEX)
// #define I_ARG(INDEX) INT_ARG(INDEX)
// #define T_ARG(INDEX) block.getTArguments()->at(INDEX)
// #define B_ARG(INDEX) block.getBArguments()->at(INDEX)

// #define COPY_SHAPE(SRC, TGT) TGT = ShapeBuilders::copyShapeInfo(SRC, true, block.getWorkspace())

// #define COPY_SHAPE_EX(SRC, TGT, WORKSPACE) TGT = ShapeBuilders::copyShapeInfo(SRC, true, WORKSPACE)

// #define CHECK_ALLOC(PTR, MSG, BYTES)
//   if (PTR == nullptr) {
//     throw sd::allocation_exception::build(MSG, BYTES);
//   };

// #ifdef __CUDABLAS__

// #define LAMBDA_T(X, ...) [=] SD_HOST_DEVICE(T X) -> T
// #define LAMBDA_TT(X, Y, ...) [=] SD_DEVICE(T X, T Y) -> T
// #define LAMBDA_TTT(t, u, v, ...) [=] SD_DEVICE(T t, T u, T v) -> T

// #define ILAMBDA_T(X, ...) [=] SD_DEVICE(sd::LongType _idx, T X) -> T
// #define ILAMBDA_TT(X, Y, ...) [=] SD_DEVICE(sd::LongType _idx, T X, T Y) -> T

// #define LAMBDA_D(X, ...) [=] SD_HOST_DEVICE(double X) -> double
// #define LAMBDA_DD(X, Y, ...) [=] SD_HOST_DEVICE(double X, double Y) -> double
// #define LAMBDA_DDD(t, u, v, ...) [=] SD_HOST_DEVICE(double t, double u, double v) -> double

// #define LAMBDA_H(X, ...) [__VA_ARGS__] SD_HOST_DEVICE(float16 X) -> float16
// #define LAMBDA_HH(X, Y, ...) [__VA_ARGS__] SD_HOST_DEVICE(float16 X, float16 Y) -> float16

// #define ILAMBDA_D(X, ...) [__VA_ARGS__] SD_HOST_DEVICE(sd::LongType _idx, double X) -> double
// #define ILAMBDA_DD(X, Y, ...) [__VA_ARGS__] SD_HOST_DEVICE(sd::LongType _idx, double X, double Y) -> double

// #define ILAMBDA_F(X, ...) [__VA_ARGS__] SD_HOST_DEVICE(sd::LongType _idx, float X) -> float
// #define ILAMBDA_FF(X, Y, ...) [__VA_ARGS__] SD_HOST_DEVICE(sd::LongType _idx, float X, float Y) -> float

// #define LAMBDA_F(X, ...) [__VA_ARGS__] SD_HOST_DEVICE(float X) -> float
// #define LAMBDA_FF(X, Y, ...) [__VA_ARGS__] SD_HOST_DEVICE(float X, float Y) -> float
// #define LAMBDA_FFF(t, u, v, ...) [__VA_ARGS__] SD_HOST_DEVICE(float t, float u, float v) -> float

// #else

// #endif

// stuff for benchmarks
// #define GENERATE_XYZ() [&](ResultSet & x, ResultSet & y, ResultSet & z)
// #define GENERATE_XZ() [&](ResultSet & x, ResultSet & z)

// #define PARAMETRIC_XYZ() [&](Parameters & p, ResultSet & x, ResultSet & y, ResultSet & z)
// #define PARAMETRIC_XZ() [&](Parameters & p, ResultSet & x, ResultSet & z)

// #define PARAMETRIC_D() [&](Parameters & p) -> Context*

// #ifdef __CUDABLAS__
// #define checkCudaErrors(ERR)
//   if (ERR != 0) {
//     throw std::runtime_error("CUDA stream synchronization failed");
//   }
// #endif

// #endif


// Parsed from ops/InputType.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef ND4J_INPUTTYPE_H
// #define ND4J_INPUTTYPE_H
/** enum sd::ops::InputType */
public static final int
  InputType_BOOLEAN = 0,
  InputType_NUMERIC = 1,
  InputType_STRINGULAR = 2,
  InputType_NUMERIC_SET = 3,
  InputType_STRINGULAR_SET = 4;

  // namespace sd

// #endif


// Parsed from ops/declarable/OpDescriptor.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef LIBND4J_OPDESCRIPTOR_H
// #define LIBND4J_OPDESCRIPTOR_H
// #include 
// #include 
// #include 
// #include 

// #include 
// #include 
// #include 

/**
 *   This class is very basic info holder for ops. bean/pojo pretty much.
 *
 */
@Namespace("sd::ops") @NoOffset public static class OpDescriptor extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public OpDescriptor(Pointer p) { super(p); }

  // default constructor
  public OpDescriptor(int numInputs, int numOutputs, @StdString BytePointer opName, @Cast("bool") boolean allowsInplace) { super((Pointer)null); allocate(numInputs, numOutputs, opName, allowsInplace); }
  private native void allocate(int numInputs, int numOutputs, @StdString BytePointer opName, @Cast("bool") boolean allowsInplace);
  public OpDescriptor(int numInputs, int numOutputs, @StdString String opName, @Cast("bool") boolean allowsInplace) { super((Pointer)null); allocate(numInputs, numOutputs, opName, allowsInplace); }
  private native void allocate(int numInputs, int numOutputs, @StdString String opName, @Cast("bool") boolean allowsInplace);

  // constructor for boolean ops
  public OpDescriptor(int numInputs, @StdString BytePointer opName, @Cast("bool") boolean isScalar) { super((Pointer)null); allocate(numInputs, opName, isScalar); }
  private native void allocate(int numInputs, @StdString BytePointer opName, @Cast("bool") boolean isScalar);
  public OpDescriptor(int numInputs, @StdString String opName, @Cast("bool") boolean isScalar) { super((Pointer)null); allocate(numInputs, opName, isScalar); }
  private native void allocate(int numInputs, @StdString String opName, @Cast("bool") boolean isScalar);

  // default constructor

  // constructor for configurable op
  public OpDescriptor(int numInputs, int numOutputs, @Cast("char*") String opName, @Cast("bool") boolean allowsInplace, int tArgs, int iArgs) { super((Pointer)null); allocate(numInputs, numOutputs, opName, allowsInplace, tArgs, iArgs); }
  private native void allocate(int numInputs, int numOutputs, @Cast("char*") String opName, @Cast("bool") boolean allowsInplace, int tArgs, int iArgs);
  public OpDescriptor(int numInputs, int numOutputs, @Cast("char*") BytePointer opName, @Cast("bool") boolean allowsInplace, int tArgs, int iArgs) { super((Pointer)null); allocate(numInputs, numOutputs, opName, allowsInplace, tArgs, iArgs); }
  private native void allocate(int numInputs, int numOutputs, @Cast("char*") BytePointer opName, @Cast("bool") boolean allowsInplace, int tArgs, int iArgs);

  // constructor for non-configurable divergent op
  public OpDescriptor(int numInputs, int numOutputs, @StdString BytePointer opName, @Cast("bool") boolean allowsInplace, @Cast("bool") boolean divergent) { super((Pointer)null); allocate(numInputs, numOutputs, opName, allowsInplace, divergent); }
  private native void allocate(int numInputs, int numOutputs, @StdString BytePointer opName, @Cast("bool") boolean allowsInplace, @Cast("bool") boolean divergent);
  public OpDescriptor(int numInputs, int numOutputs, @StdString String opName, @Cast("bool") boolean allowsInplace, @Cast("bool") boolean divergent) { super((Pointer)null); allocate(numInputs, numOutputs, opName, allowsInplace, divergent); }
  private native void allocate(int numInputs, int numOutputs, @StdString String opName, @Cast("bool") boolean allowsInplace, @Cast("bool") boolean divergent);

  // constructor for non-configurable divergent op

  // constructor for configurable divergent op
  public OpDescriptor(int numInputs, int numOutputs, @Cast("char*") String opName, @Cast("bool") boolean allowsInplace, @Cast("bool") boolean divergent, int tArgs,
                 int iArgs) { super((Pointer)null); allocate(numInputs, numOutputs, opName, allowsInplace, divergent, tArgs, iArgs); }
  private native void allocate(int numInputs, int numOutputs, @Cast("char*") String opName, @Cast("bool") boolean allowsInplace, @Cast("bool") boolean divergent, int tArgs,
                 int iArgs);
  public OpDescriptor(int numInputs, int numOutputs, @Cast("char*") BytePointer opName, @Cast("bool") boolean allowsInplace, @Cast("bool") boolean divergent, int tArgs,
                 int iArgs) { super((Pointer)null); allocate(numInputs, numOutputs, opName, allowsInplace, divergent, tArgs, iArgs); }
  private native void allocate(int numInputs, int numOutputs, @Cast("char*") BytePointer opName, @Cast("bool") boolean allowsInplace, @Cast("bool") boolean divergent, int tArgs,
                 int iArgs);

  // constructor for logical ops (while, scope, etc)
  public OpDescriptor(@Cast("char*") String opName, @Cast("bool") boolean isLogic) { super((Pointer)null); allocate(opName, isLogic); }
  private native void allocate(@Cast("char*") String opName, @Cast("bool") boolean isLogic);
  public OpDescriptor(@Cast("char*") BytePointer opName, @Cast("bool") boolean isLogic) { super((Pointer)null); allocate(opName, isLogic); }
  private native void allocate(@Cast("char*") BytePointer opName, @Cast("bool") boolean isLogic);

  public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef OpDescriptor other);

  // default destructor

  // this method returns minimal expected number of T arguments
  public native int getNumberOfTArgs();

  // this method returns minimal expected number of Integer arguments
  public native int getNumberOfIArgs();

  // this method returns minimal expected number of inputs
  public native int getNumberOfInputs();

  // this method returns hash code for this operation
  public native @Cast("sd::LongType") long getHash();

  // this method returns minimal expected number of outputs
  public native int getNumberOfOutputs();

  // this method returns opName (can be empty)
  public native @StdString @Cast({"char*", "std::string*"}) BytePointer getOpName();

  // returns TRUE if this op is divergent. FALSE otherwise
  public native @Cast("bool") boolean isDivergent();

  // returns TRUE if this op allows in-place execution
  public native @Cast("bool") boolean allowsInplace();

  // this method allows you to enable/disable inplace call for a given op
  public native void allowInplace(@Cast("bool") boolean reallyAllow);

  // this method returns opNum (applicable for legacy XYZ ops only)
  public native int getOpNum();

  // this method allows to set specifc opNum
  public native void setOpNum(int opNum);

  public native void setHash(@Cast("sd::LongType") long hash);

  public native @Cast("sd::ops::InputType") int inputType();

  public native OpDescriptor setInputType(@Cast("sd::ops::InputType") int type);
  public native OpDescriptor setAllowedInputTypes(int index, @Cast("sd::DataType*") @StdVector IntPointer dtype);
  public native OpDescriptor setAllowedInputTypes(int index, @Cast("sd::DataType*") @StdVector IntBuffer dtype);
  public native OpDescriptor setAllowedInputTypes(int index, @Cast("sd::DataType*") @StdVector int[] dtype);
  public native OpDescriptor setAllowedOutputTypes(int index, @Cast("sd::DataType*") @StdVector IntPointer dtype);
  public native OpDescriptor setAllowedOutputTypes(int index, @Cast("sd::DataType*") @StdVector IntBuffer dtype);
  public native OpDescriptor setAllowedOutputTypes(int index, @Cast("sd::DataType*") @StdVector int[] dtype);
  public native OpDescriptor setAllowedInputTypes(int index, @Cast("sd::DataType") int dtype);
  public native OpDescriptor setAllowedOutputTypes(int index, @Cast("sd::DataType") int dtype);
  public native OpDescriptor setAllowedInputTypes(@Cast("sd::DataType") int dtype);
  public native OpDescriptor setAllowedOutputTypes(@Cast("sd::DataType") int dtype);
  public native OpDescriptor allowOverride(@Cast("bool") boolean reallyAllow);
  public native OpDescriptor setSameMode(@Cast("bool") boolean reallySame);
  public native OpDescriptor setInputType(int idx, @Cast("sd::DataType") int dtype);
  public native OpDescriptor setOutputType(int idx, @Cast("sd::DataType") int dtype);

  public native @Cast("sd::DataType*") @StdVector IntPointer getOutputTypesForOutput(int index);

  public native @Cast("bool") boolean checkInputMatch(int index, @Cast("sd::DataType") int dataType);
  public native @Cast("bool") boolean checkOutputMatch(int index, @Cast("sd::DataType") int dataType);
  public native @Cast("bool") boolean isSameMode();

  public native @Cast("bool") boolean isInherit(int index);
}
  // namespace ops
  // namespace sd

// #endif  // LIBND4J_OPDESCRIPTOR_H


// Parsed from ops/declarable/PlatformHelper.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef SD_PLATFORMHELPER_H
// #define SD_PLATFORMHELPER_H
// #include 
// #include 
// #include 
// #include 

// #include 
/**
 * This abstract class defines methods used by platform-specific helpers implementations
 */
@Namespace("sd::ops::platforms") @NoOffset public static class PlatformHelper extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public PlatformHelper(Pointer p) { super(p); }


  public native @StdString BytePointer name();

  public native @Cast("samediff::Engine") int engine();

  public native @Cast("sd::LongType") long hash();

  /**
   * This method checks, if given helper can be used with given input/output/configuration options
   *
   * @param context
   * @return
   */
  public native @Cast("bool") boolean isUsable(@ByRef Context context);

  /**
   * This method invokes helper. Typically this method replaces actual op execution
   *
   * @param context
   * @return
   */
  public native @Cast("sd::Status") int invokeHelper(@ByRef Context context);

  /**
   * Helper method, needed for compatibility with DeclarableOp macros
   * @param ctx
   * @param inputId
   * @return
   */
  public native NDArray getZ(@ByRef Context ctx, int inputId);

  /**
   * Helper method, needed for compatibility with DeclarableOp macros
   * @param ctx
   * @param inputId
   * @return
   */
  public native NDArray getNullifiedZ(@ByRef Context ctx, int inputId);
}
  // namespace platforms
  // namespace ops
  // namespace sd

// #endif  // SD_PLATFORMHELPER_H


// Parsed from ops/declarable/BroadcastableOp.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver on 6/6/2018.
//

// #ifndef LIBND4J_BROADCASTABLEOP_H
// #define LIBND4J_BROADCASTABLEOP_H

// #include 
@Namespace("sd::ops") public static class BroadcastableOp extends DeclarableCustomOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public BroadcastableOp(Pointer p) { super(p); }


  public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
}
  // namespace ops
  // namespace sd

// #endif  // LIBND4J_BROADCASTABLEOP_H


// Parsed from ops/declarable/BroadcastableBoolOp.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver on 6/6/2018.
//

// #ifndef SD_BROADCASTABLEBOOLOP_H
// #define SD_BROADCASTABLEBOOLOP_H
// #include 

// #include "DeclarableCustomOp.h"
// #include "DeclarableOp.h"
// #include "OpDescriptor.h"
@Namespace("sd::ops") public static class BroadcastableBoolOp extends DeclarableCustomOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public BroadcastableBoolOp(Pointer p) { super(p); }


  public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
}
  // namespace ops
  // namespace sd

// #endif  // SD_BROADCASTABLEBOOLOP_H


// Parsed from helpers/OpArgsHolder.h

/* ******************************************************************************
 *
 *
 * 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 Yurii Shyrma ([email protected]), created on 15.07.2018
//

// #ifndef LIBND4J_OPARGSHOLDER_H
// #define LIBND4J_OPARGSHOLDER_H

// #include 

@Namespace("sd") @NoOffset public static class OpArgsHolder extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public OpArgsHolder(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public OpArgsHolder(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public OpArgsHolder position(long position) {
        return (OpArgsHolder)super.position(position);
    }
    @Override public OpArgsHolder getPointer(long i) {
        return new OpArgsHolder((Pointer)this).offsetAddress(i);
    }

  // default constructor
  public OpArgsHolder() { super((Pointer)null); allocate(); }
  private native void allocate();

  // copy constructor
  public OpArgsHolder(@Const @ByRef OpArgsHolder other) { super((Pointer)null); allocate(other); }
  private native void allocate(@Const @ByRef OpArgsHolder other);

  // constructor
  public OpArgsHolder(@Const @ByRef NDArrayVector inArrs, @StdVector DoublePointer tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector LongPointer iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/) { super((Pointer)null); allocate(inArrs, tArgs, iArgs, bArgs); }
  private native void allocate(@Const @ByRef NDArrayVector inArrs, @StdVector DoublePointer tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector LongPointer iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/);
  public OpArgsHolder(@Const @ByRef NDArrayVector inArrs) { super((Pointer)null); allocate(inArrs); }
  private native void allocate(@Const @ByRef NDArrayVector inArrs);
  public OpArgsHolder(@Const @ByRef NDArrayVector inArrs, @StdVector DoubleBuffer tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector LongBuffer iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/) { super((Pointer)null); allocate(inArrs, tArgs, iArgs, bArgs); }
  private native void allocate(@Const @ByRef NDArrayVector inArrs, @StdVector DoubleBuffer tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector LongBuffer iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/);
  public OpArgsHolder(@Const @ByRef NDArrayVector inArrs, @StdVector double[] tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector long[] iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/) { super((Pointer)null); allocate(inArrs, tArgs, iArgs, bArgs); }
  private native void allocate(@Const @ByRef NDArrayVector inArrs, @StdVector double[] tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector long[] iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/);
  public OpArgsHolder(@Const @ByRef NDArrayVector inArrs, @StdVector DoublePointer tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector LongPointer iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/) { super((Pointer)null); allocate(inArrs, tArgs, iArgs, bArgs); }
  private native void allocate(@Const @ByRef NDArrayVector inArrs, @StdVector DoublePointer tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector LongPointer iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/);
  public OpArgsHolder(@Const @ByRef NDArrayVector inArrs, @StdVector DoubleBuffer tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector LongBuffer iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/) { super((Pointer)null); allocate(inArrs, tArgs, iArgs, bArgs); }
  private native void allocate(@Const @ByRef NDArrayVector inArrs, @StdVector DoubleBuffer tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector LongBuffer iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/);
  public OpArgsHolder(@Const @ByRef NDArrayVector inArrs, @StdVector double[] tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector long[] iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/) { super((Pointer)null); allocate(inArrs, tArgs, iArgs, bArgs); }
  private native void allocate(@Const @ByRef NDArrayVector inArrs, @StdVector double[] tArgs/*=std::vector()*/,
                 @Cast("sd::LongType*") @StdVector long[] iArgs/*=std::vector()*/,
                 @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/);

  // move constructor

  // assignment operator
  public native @ByRef @Name("operator =") OpArgsHolder put(@Const @ByRef OpArgsHolder other);

  // move assignment operator

  public native @Const @ByRef NDArrayVector getInArrs();

  public native @StdVector DoublePointer getTArgs();

  public native @Cast("sd::LongType*") @StdVector LongPointer getIArgs();

  public native @Cast("bool*") @StdVector BooleanPointer getBArgs();

  public native @Cast("bool*") @StdVector BooleanPointer getAllocInfo();

  public native int getNumInArrs();

  public native int getNumTArgs();

  public native int getNumIArgs();

  public native int getNumBArgs();

  public native @ByVal OpArgsHolder createArgsHolderForBP(@Const @ByRef NDArrayVector inGradArrs, @Cast("const bool") boolean isInPlace/*=false*/);
  public native @ByVal OpArgsHolder createArgsHolderForBP(@Const @ByRef NDArrayVector inGradArrs);
}

  // namespace sd

// #endif  // LIBND4J_OPARGSHOLDER_H


// Parsed from ops/declarable/DeclarableOp.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef LIBND4J_DECLARABLE_OPS_H
// #define LIBND4J_DECLARABLE_OPS_H
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 

// #include 
// #include 
// #include 
// #include 

@Namespace("sd::ops") public native @Cast("sd::Status") int conditionHelper(@Cast("char*") String file, int line, int condition, int argNumber, @Cast("char*") String format);
@Namespace("sd::ops") public native @Cast("sd::Status") int conditionHelper(@Cast("char*") BytePointer file, int line, int condition, int argNumber, @Cast("char*") BytePointer format);

/**
 * This class is the basic building block of Graph Operations. Any CustomOp out there is built on top of this "abstract"
 * class.
 *
 */
@Namespace("sd::ops") @NoOffset public static class DeclarableOp extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DeclarableOp(Pointer p) { super(p); }

  // for special cases, like BooleanOps

  // regular constructors

  // for LogicalOps

  // default testructor

  // this method returns OpDescriptor, describing this Op instance
  public native OpDescriptor getOpDescriptor();

  public native @Cast("sd::Status") int validateDataTypes(@ByRef Context block);

  /**
   *   This method should be available in each implemented Op, and should return Op output shape(s), for a given input
   * shape(s)
   */
  public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);

  /**
   * Returns opName
   *
   * @return
   */
  public native @StdString @Cast({"char*", "std::string*"}) BytePointer getOpName();

  /**
   * Returns opHash
   */
  public native @Cast("sd::LongType") long getOpHash();

  /**
   * This method sets arguments for op
   */
  //            void setArguments();

  /**
   * This method returns pointer to results
   */
  //            void getResults();

  /**
   * This method executes given Op
   *
   * @param block
   * @return 0 if OK, error code otherwise
   */
  public native @Cast("sd::Status") int execute(Context block);

  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs);

  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector DoublePointer tArgs, @Cast("sd::LongType*") @StdVector LongPointer iArgs,
                       @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/,
                       @Cast("sd::DataType*") @StdVector IntPointer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector DoublePointer tArgs, @Cast("sd::LongType*") @StdVector LongPointer iArgs);
  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector DoubleBuffer tArgs, @Cast("sd::LongType*") @StdVector LongBuffer iArgs,
                       @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/,
                       @Cast("sd::DataType*") @StdVector IntBuffer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector DoubleBuffer tArgs, @Cast("sd::LongType*") @StdVector LongBuffer iArgs);
  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector double[] tArgs, @Cast("sd::LongType*") @StdVector long[] iArgs,
                       @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/,
                       @Cast("sd::DataType*") @StdVector int[] dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector double[] tArgs, @Cast("sd::LongType*") @StdVector long[] iArgs);
  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector DoublePointer tArgs, @Cast("sd::LongType*") @StdVector LongPointer iArgs,
                       @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/,
                       @Cast("sd::DataType*") @StdVector IntPointer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector DoubleBuffer tArgs, @Cast("sd::LongType*") @StdVector LongBuffer iArgs,
                       @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/,
                       @Cast("sd::DataType*") @StdVector IntBuffer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @Cast("sd::Status") int execute(@Const @ByRef NDArrayVector inputs, @Const @ByRef NDArrayVector outputs,
                       @StdVector double[] tArgs, @Cast("sd::LongType*") @StdVector long[] iArgs,
                       @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/,
                       @Cast("sd::DataType*") @StdVector int[] dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);

  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs);

  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector DoublePointer tArgs,
                           @Cast("sd::LongType*") @StdVector LongPointer iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/,
                           @Cast("sd::DataType*") @StdVector IntPointer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector DoublePointer tArgs,
                           @Cast("sd::LongType*") @StdVector LongPointer iArgs);
  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector DoubleBuffer tArgs,
                           @Cast("sd::LongType*") @StdVector LongBuffer iArgs, @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/,
                           @Cast("sd::DataType*") @StdVector IntBuffer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector DoubleBuffer tArgs,
                           @Cast("sd::LongType*") @StdVector LongBuffer iArgs);
  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector double[] tArgs,
                           @Cast("sd::LongType*") @StdVector long[] iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/,
                           @Cast("sd::DataType*") @StdVector int[] dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector double[] tArgs,
                           @Cast("sd::LongType*") @StdVector long[] iArgs);
  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector DoublePointer tArgs,
                           @Cast("sd::LongType*") @StdVector LongPointer iArgs, @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/,
                           @Cast("sd::DataType*") @StdVector IntPointer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector DoubleBuffer tArgs,
                           @Cast("sd::LongType*") @StdVector LongBuffer iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs/*=std::vector()*/,
                           @Cast("sd::DataType*") @StdVector IntBuffer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);
  public native @ByVal ResultSet evaluate(@Const @ByRef NDArrayVector inputs, @StdVector double[] tArgs,
                           @Cast("sd::LongType*") @StdVector long[] iArgs, @Cast("bool*") @StdVector boolean[] bArgs/*=std::vector()*/,
                           @Cast("sd::DataType*") @StdVector int[] dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/);

  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector DoublePointer tArgs,
                       @Cast("sd::LongType*") @StdVector LongPointer iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs,
                       @Cast("sd::DataType*") @StdVector IntPointer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/,
                       @Cast("sd::DataType") int type/*=sd::DataType::FLOAT32*/);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector DoublePointer tArgs,
                       @Cast("sd::LongType*") @StdVector LongPointer iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector DoubleBuffer tArgs,
                       @Cast("sd::LongType*") @StdVector LongBuffer iArgs, @Cast("bool*") @StdVector boolean[] bArgs,
                       @Cast("sd::DataType*") @StdVector IntBuffer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/,
                       @Cast("sd::DataType") int type/*=sd::DataType::FLOAT32*/);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector DoubleBuffer tArgs,
                       @Cast("sd::LongType*") @StdVector LongBuffer iArgs, @Cast("bool*") @StdVector boolean[] bArgs);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector double[] tArgs,
                       @Cast("sd::LongType*") @StdVector long[] iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs,
                       @Cast("sd::DataType*") @StdVector int[] dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/,
                       @Cast("sd::DataType") int type/*=sd::DataType::FLOAT32*/);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector double[] tArgs,
                       @Cast("sd::LongType*") @StdVector long[] iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector DoublePointer tArgs,
                       @Cast("sd::LongType*") @StdVector LongPointer iArgs, @Cast("bool*") @StdVector boolean[] bArgs,
                       @Cast("sd::DataType*") @StdVector IntPointer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/,
                       @Cast("sd::DataType") int type/*=sd::DataType::FLOAT32*/);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector DoublePointer tArgs,
                       @Cast("sd::LongType*") @StdVector LongPointer iArgs, @Cast("bool*") @StdVector boolean[] bArgs);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector DoubleBuffer tArgs,
                       @Cast("sd::LongType*") @StdVector LongBuffer iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs,
                       @Cast("sd::DataType*") @StdVector IntBuffer dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/,
                       @Cast("sd::DataType") int type/*=sd::DataType::FLOAT32*/);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector DoubleBuffer tArgs,
                       @Cast("sd::LongType*") @StdVector LongBuffer iArgs, @Cast("bool*") @StdVector BooleanPointer bArgs);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector double[] tArgs,
                       @Cast("sd::LongType*") @StdVector long[] iArgs, @Cast("bool*") @StdVector boolean[] bArgs,
                       @Cast("sd::DataType*") @StdVector int[] dArgs/*=std::vector()*/, @Cast("bool") boolean isInplace/*=false*/,
                       @Cast("sd::DataType") int type/*=sd::DataType::FLOAT32*/);
  public native @Cast("sd::Status") int execute(@ByRef RandomGenerator rng, @Const @ByRef NDArrayVector inputs,
                       @Const @ByRef NDArrayVector outputs, @StdVector double[] tArgs,
                       @Cast("sd::LongType*") @StdVector long[] iArgs, @Cast("bool*") @StdVector boolean[] bArgs);

  public native @ByVal ResultSet execute(@Const @ByRef OpArgsHolder holder, @Cast("bool") boolean isInplace/*=false*/);
  public native @ByVal ResultSet execute(@Const @ByRef OpArgsHolder holder);

  // There methods provide various validation options
  public native @Cast("sd::Status") int validateNonEmptyInput(@ByRef Context block);

  // this method checks if all input arrays have equal lengths
  public native @Cast("sd::Status") int validateInputLengthMatch(@ByRef Context block);

  // this method checks if all input arrays have the same shapes (orders/strides are NOT checked)
  public native @Cast("sd::Status") int validateInputDimensionsMatch(@ByRef Context block);

  // this method check if all input arrays have the same orders
  public native @Cast("sd::Status") int validateOrdersMatch(@ByRef Context block);

  // this method checks if all input arrays are 2D
  public native @Cast("sd::Status") int validateInput2D(@ByRef Context block);

  // this method checks if all input arrays are 3D
  public native @Cast("sd::Status") int validateInput3D(@ByRef Context block);

  // this method checks if all input arrays are 4D
  public native @Cast("sd::Status") int validateInput4D(@ByRef Context block);

  // this method checks if all input arrays are ND
  public native @Cast("sd::Status") int validateInputDimensions(@ByRef Context block, int rank);

  // this method checks if number of available arguments matches op expectations
  public native @Cast("sd::Status") int validateArguments(@ByRef Context block);
  public native void overwriteResult(@ByRef Context block, int outputIdx, NDArray array, @Cast("bool") boolean remove);
}
  // namespace ops
  // namespace sd

// #endif  // LIBND4J_DECLARABLE_OPS_H


// Parsed from ops/declarable/DeclarableListOp.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef LIBND4J_DECLARABLE_LIST_OP_H
// #define LIBND4J_DECLARABLE_LIST_OP_H
// #include 
// #include 
// #include 
// #include 
@Namespace("sd::ops") public static class DeclarableListOp extends DeclarableOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DeclarableListOp(Pointer p) { super(p); }


  public native @Cast("sd::Status") int execute(Context block);
  public native @ByVal ResultSet execute(NDArrayList list, @ByRef NDArrayVector inputs, @StdVector DoublePointer tArgs,
                      @StdVector IntPointer iArgs);
  public native @ByVal ResultSet execute(NDArrayList list, @ByRef NDArrayVector inputs, @StdVector DoubleBuffer tArgs,
                      @StdVector IntBuffer iArgs);
  public native @ByVal ResultSet execute(NDArrayList list, @ByRef NDArrayVector inputs, @StdVector double[] tArgs,
                      @StdVector int[] iArgs);

  public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
}
  // namespace ops
  // namespace sd

// #endif


// Parsed from ops/declarable/DeclarableReductionOp.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 07.10.2017.
//

// #ifndef LIBND4J_DECLARABLE_REDUCTION_OP_H
// #define LIBND4J_DECLARABLE_REDUCTION_OP_H
// #include 
@Namespace("sd::ops") public static class DeclarableReductionOp extends DeclarableOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DeclarableReductionOp(Pointer p) { super(p); }


  public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
}
  // namespace ops
  // namespace sd

// #endif  // LIBND4J_DECLARABLE_REDUCTION_OP_H


// Parsed from ops/declarable/DeclarableCustomOp.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 07.10.2017.
//

// #ifndef LIBND4J_DECLARABLECUSTOMOP_H
// #define LIBND4J_DECLARABLECUSTOMOP_H
// #include 
@Namespace("sd::ops") public static class DeclarableCustomOp extends DeclarableOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DeclarableCustomOp(Pointer p) { super(p); }


  public native ShapeList calculateOutputShape(ShapeList inputShapes, @ByRef Context block);
}
  // namespace ops
  // namespace sd

// #endif  // LIBND4J_DECLARABLECUSTOMOP_H


// Parsed from ops/declarable/BooleanOp.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 13.10.2017.
//

// #ifndef LIBND4J_BOOLEANOP_H
// #define LIBND4J_BOOLEANOP_H
// #include 

// #include "DeclarableOp.h"
// #include "OpDescriptor.h"
@Namespace("sd::ops") @NoOffset public static class BooleanOp extends DeclarableOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public BooleanOp(Pointer p) { super(p); }


  public native @Cast("bool") boolean verify(@Const @ByRef NDArrayVector args);
  public native @Cast("bool") boolean verify(@ByRef Context block);

  public native @Cast("sd::Status") int execute(Context block);

  public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
}
  // namespace ops
  // namespace sd

// #endif  // LIBND4J_BOOLEANOP_H


// Parsed from ops/declarable/LogicOp.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 15.10.2017.
//

// #ifndef LIBND4J_LOGICOP_H
// #define LIBND4J_LOGICOP_H
// #include "DeclarableOp.h"

/**
 * Logic ops are unique snowflakes in any Graph. They dramatically change Graph Execution process, by introducing loops,
 * conditions, etc.
 *
 * Their code is the part of GraphExecutioner logic. But we still want them to be expressed via Graph
 * \tparam T
 */
@Namespace("sd::ops") public static class LogicOp extends DeclarableOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public LogicOp(Pointer p) { super(p); }

  public LogicOp(@Cast("char*") String name) { super((Pointer)null); allocate(name); }
  private native void allocate(@Cast("char*") String name);
  public LogicOp(@Cast("char*") BytePointer name) { super((Pointer)null); allocate(name); }
  private native void allocate(@Cast("char*") BytePointer name);

  public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
}
  // namespace ops
  // namespace sd

// #endif  // LIBND4J_LOGICOP_H


// Parsed from ops/declarable/OpRegistrator.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 07.10.2017.
//

// #ifndef LIBND4J_OPREGISTRATOR_H
// #define LIBND4J_OPREGISTRATOR_H

// #include 
// #include 
// #include 
// #include 

// #include 
// #include 
// #include 

// handlers part
// #include 
// #include 

// #ifndef __JAVACPP_HACK__

// #endif
/**
 *   This class provides runtime ops lookup, based on opName or opHash.
 *   To build lookup directory we use *_OP_IMPL macro, which puts static structs at compile time in .cpp files,
 *   so once binary is executed, static objects are initialized automatically, and we get list of all ops
 *   available at runtime via this singleton.
 *
 */
@Namespace("sd::ops") @NoOffset public static class OpRegistrator extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public OpRegistrator(Pointer p) { super(p); }


  public native @ByRef OpRegistrator getInstance();

  public native void exitHandler();
  public native void sigIntHandler(int sig);
  public native void sigSegVHandler(int sig);

  
  public native @Cast("char*") String getAllCustomOperations();

  /**
   * This method registers operation in our registry, so we can use them later
   *
   * @param op
   */
  public native @Cast("bool") boolean registerOperation(@Cast("char*") String name, DeclarableOp op);
  public native @Cast("bool") boolean registerOperation(@Cast("char*") BytePointer name, DeclarableOp op);
  public native @Cast("bool") boolean registerOperation(DeclarableOp op);

  public native void registerHelper(PlatformHelper op);

  public native @Cast("bool") boolean hasHelper(@Cast("sd::LongType") long hash, @Cast("samediff::Engine") int engine);

  public native DeclarableOp getOperation(@Cast("char*") String name);
  public native DeclarableOp getOperation(@Cast("char*") BytePointer name);
  public native DeclarableOp getOperation(@Cast("sd::LongType") long hash);

  public native PlatformHelper getPlatformHelper(@Cast("sd::LongType") long hash, @Cast("samediff::Engine") int engine);

// #ifndef __JAVACPP_HACK__
// #endif
  public native @Cast("sd::LongType*") @StdVector LongPointer getAllHashes();

  public native int numberOfOperations();
}

/*
 *  These structs are used to "register" our ops in OpRegistrator.
 */

  // namespace ops
  // namespace sd

// #endif  // LIBND4J_OPREGISTRATOR_H


// Parsed from execution/ContextBuffers.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef LIBND4J_CONTEXTBUFFERS_H
// #define LIBND4J_CONTEXTBUFFERS_H

// #include 
// #include 
@Namespace("sd") @NoOffset public static class ContextBuffers extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ContextBuffers(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ContextBuffers(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ContextBuffers position(long position) {
        return (ContextBuffers)super.position(position);
    }
    @Override public ContextBuffers getPointer(long i) {
        return new ContextBuffers((Pointer)this).offsetAddress(i);
    }

  public ContextBuffers() { super((Pointer)null); allocate(); }
  private native void allocate();
  public ContextBuffers(@Const @ByRef ContextBuffers other) { super((Pointer)null); allocate(other); }
  private native void allocate(@Const @ByRef ContextBuffers other);
  public ContextBuffers(Pointer rPointer, Pointer sPointer, Pointer aPointer, @Cast("bool") boolean isOwner/*=false*/) { super((Pointer)null); allocate(rPointer, sPointer, aPointer, isOwner); }
  private native void allocate(Pointer rPointer, Pointer sPointer, Pointer aPointer, @Cast("bool") boolean isOwner/*=false*/);
  public ContextBuffers(Pointer rPointer, Pointer sPointer, Pointer aPointer) { super((Pointer)null); allocate(rPointer, sPointer, aPointer); }
  private native void allocate(Pointer rPointer, Pointer sPointer, Pointer aPointer);

  public native @ByRef @Name("operator =") ContextBuffers put(@Const @ByRef ContextBuffers other);

  public native void release();

  public native Pointer reductionBuffer();
  public native Pointer scalarBuffer();
  public native Pointer allocationBuffer();

  public native Pointer execStream();
  public native Pointer specialStream();

  public native void setReductionBuffer(Pointer pointer);
  public native void setScalarBuffer(Pointer pointer);
  public native void setAllocationBuffer(Pointer pointer);

  public native ErrorReference errorReference();

  public native void triggerOwnership(@Cast("bool") boolean isOwner);

  public native int deviceId();

  public native @Cast("bool") boolean isInitialized();
}
  // namespace sd

// #endif  // DEV_TESTS_CONTEXTBUFFERS_H


// Parsed from execution/LaunchContext.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 30.11.17.
//

// #ifndef LIBND4J_CUDACONTEXT_H
// #define LIBND4J_CUDACONTEXT_H

// #ifdef __CUDABLAS__
// #include 
// #include 
// #include 
// #include 

// #include "config.h"
// #endif

// used for MKLDNN etc
// #if !defined(__STANDALONE_BUILD__)
// #include "config.h"
// #endif

// #include 
// #include 
// #include 
// #include 
// #include 

// #include 
// #include 
// #include 

@Namespace("sd") @NoOffset public static class LaunchContext extends Pointer {
    static { Loader.load(); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public LaunchContext(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public LaunchContext position(long position) {
        return (LaunchContext)super.position(position);
    }
    @Override public LaunchContext getPointer(long i) {
        return new LaunchContext((Pointer)this).offsetAddress(i);
    }

// #ifdef __CUDABLAS__

// #ifndef __JAVACPP_HACK__

// #endif  // JCPP

// #endif  // CUDA
  public LaunchContext(@Cast("sd::Pointer") Pointer cudaStream, @Cast("sd::Pointer") Pointer reductionPointer/*=nullptr*/, @Cast("sd::Pointer") Pointer scalarPointer/*=nullptr*/,
                  @Cast("sd::Pointer") Pointer allocationPointer/*=nullptr*/) { super((Pointer)null); allocate(cudaStream, reductionPointer, scalarPointer, allocationPointer); }
  private native void allocate(@Cast("sd::Pointer") Pointer cudaStream, @Cast("sd::Pointer") Pointer reductionPointer/*=nullptr*/, @Cast("sd::Pointer") Pointer scalarPointer/*=nullptr*/,
                  @Cast("sd::Pointer") Pointer allocationPointer/*=nullptr*/);
  public LaunchContext(@Cast("sd::Pointer") Pointer cudaStream) { super((Pointer)null); allocate(cudaStream); }
  private native void allocate(@Cast("sd::Pointer") Pointer cudaStream);
  public LaunchContext() { super((Pointer)null); allocate(); }
  private native void allocate();
  public native Workspace getWorkspace();
  public native void setWorkspace(Workspace theWorkspace);

  public native Pointer engine();

  public native int getDeviceID();
  public native void setDeviceID(int deviceID);
  public native ErrorReference errorReference();

// #ifndef __JAVACPP_HACK__

// #endif

  public native @Cast("bool") boolean isInitialized();
  public native void releaseBuffers();

  public native LaunchContext defaultContext();

  public native void swapContextBuffers(@ByRef ContextBuffers buffers);
}

  // namespace sd

// #endif  // LIBND4J_CUDACONTEXT_H


// Parsed from array/ShapeDescriptor.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//  @author AbdelRauf

// #ifndef DEV_TESTS_SHAPEDESCRIPTOR_H
// #define DEV_TESTS_SHAPEDESCRIPTOR_H
// #include 
// #include 
// #include 
// #include 

// #include 
// #include 
// #include 

public static final int SHAPE_DESC_OK = 0;
public static final int SHAPE_DESC_INCORRECT_STRIDES = 1;  // strides does not match shapes
public static final int SHAPE_DESC_INCORRECT_EWS = 2;      // ews neither matches stride nor continuity
public static final int SHAPE_DESC_INCORRECT_RANK = 4;     // rank > 32 or shape size and rank does not match

@Namespace("sd") @NoOffset public static class ShapeDescriptor extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public ShapeDescriptor(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public ShapeDescriptor(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public ShapeDescriptor position(long position) {
        return (ShapeDescriptor)super.position(position);
    }
    @Override public ShapeDescriptor getPointer(long i) {
        return new ShapeDescriptor((Pointer)this).offsetAddress(i);
    }

  public ShapeDescriptor(@Const @ByRef ShapeDescriptor other) { super((Pointer)null); allocate(other); }
  private native void allocate(@Const @ByRef ShapeDescriptor other);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("bool") boolean inheritDtype/*=true*/) { super((Pointer)null); allocate(shapeInfo, inheritDtype); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("bool") boolean inheritDtype/*=true*/);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongPointer shapeInfo) { super((Pointer)null); allocate(shapeInfo); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("bool") boolean inheritDtype/*=true*/) { super((Pointer)null); allocate(shapeInfo, inheritDtype); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("bool") boolean inheritDtype/*=true*/);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongBuffer shapeInfo) { super((Pointer)null); allocate(shapeInfo); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo);
  public ShapeDescriptor(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("bool") boolean inheritDtype/*=true*/) { super((Pointer)null); allocate(shapeInfo, inheritDtype); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("bool") boolean inheritDtype/*=true*/);
  public ShapeDescriptor(@Cast("const sd::LongType*") long[] shapeInfo) { super((Pointer)null); allocate(shapeInfo); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("const sd::DataType") int dtypeOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("const sd::DataType") int dtypeOverride);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("const sd::DataType") int dtypeOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("const sd::DataType") int dtypeOverride);
  public ShapeDescriptor(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("const sd::DataType") int dtypeOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("const sd::DataType") int dtypeOverride);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("const sd::LongType*") LongPointer dtypeOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("const sd::LongType*") LongPointer dtypeOverride);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("const sd::LongType*") LongBuffer dtypeOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("const sd::LongType*") LongBuffer dtypeOverride);
  public ShapeDescriptor(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("const sd::LongType*") long[] dtypeOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("const sd::LongType*") long[] dtypeOverride);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("const sd::LongType*") LongPointer dtypeOverride,
                             @Cast("const sd::LongType*") LongPointer orderOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride, orderOverride); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer shapeInfo, @Cast("const sd::LongType*") LongPointer dtypeOverride,
                             @Cast("const sd::LongType*") LongPointer orderOverride);
  public ShapeDescriptor(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("const sd::LongType*") LongBuffer dtypeOverride,
                             @Cast("const sd::LongType*") LongBuffer orderOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride, orderOverride); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer shapeInfo, @Cast("const sd::LongType*") LongBuffer dtypeOverride,
                             @Cast("const sd::LongType*") LongBuffer orderOverride);
  public ShapeDescriptor(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("const sd::LongType*") long[] dtypeOverride,
                             @Cast("const sd::LongType*") long[] orderOverride) { super((Pointer)null); allocate(shapeInfo, dtypeOverride, orderOverride); }
  private native void allocate(@Cast("const sd::LongType*") long[] shapeInfo, @Cast("const sd::LongType*") long[] dtypeOverride,
                             @Cast("const sd::LongType*") long[] orderOverride);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, @Cast("const sd::LongType") long length) { super((Pointer)null); allocate(type, length); }
  private native void allocate(@Cast("const sd::DataType") int type, @Cast("const sd::LongType") long length);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") LongPointer shape, int rank) { super((Pointer)null); allocate(type, order, shape, rank); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") LongPointer shape, int rank);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") LongBuffer shape, int rank) { super((Pointer)null); allocate(type, order, shape, rank); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") LongBuffer shape, int rank);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") long[] shape, int rank) { super((Pointer)null); allocate(type, order, shape, rank); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") long[] shape, int rank);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongPointer shape) { super((Pointer)null); allocate(type, order, shape); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongPointer shape);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape) { super((Pointer)null); allocate(type, order, shape); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector long[] shape) { super((Pointer)null); allocate(type, order, shape); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector long[] shape);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongPointer shape,
                             @Cast("sd::LongType*") @StdVector LongPointer strides) { super((Pointer)null); allocate(type, order, shape, strides); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongPointer shape,
                             @Cast("sd::LongType*") @StdVector LongPointer strides);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape,
                             @Cast("sd::LongType*") @StdVector LongBuffer strides) { super((Pointer)null); allocate(type, order, shape, strides); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape,
                             @Cast("sd::LongType*") @StdVector LongBuffer strides);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector long[] shape,
                             @Cast("sd::LongType*") @StdVector long[] strides) { super((Pointer)null); allocate(type, order, shape, strides); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector long[] shape,
                             @Cast("sd::LongType*") @StdVector long[] strides);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongPointer shape,
                             @Cast("sd::LongType*") @StdVector LongPointer strides, @Cast("const sd::LongType") long ews) { super((Pointer)null); allocate(type, order, shape, strides, ews); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongPointer shape,
                             @Cast("sd::LongType*") @StdVector LongPointer strides, @Cast("const sd::LongType") long ews);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape,
                             @Cast("sd::LongType*") @StdVector LongBuffer strides, @Cast("const sd::LongType") long ews) { super((Pointer)null); allocate(type, order, shape, strides, ews); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector LongBuffer shape,
                             @Cast("sd::LongType*") @StdVector LongBuffer strides, @Cast("const sd::LongType") long ews);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector long[] shape,
                             @Cast("sd::LongType*") @StdVector long[] strides, @Cast("const sd::LongType") long ews) { super((Pointer)null); allocate(type, order, shape, strides, ews); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("sd::LongType*") @StdVector long[] shape,
                             @Cast("sd::LongType*") @StdVector long[] strides, @Cast("const sd::LongType") long ews);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") LongPointer shape,
                             @Cast("const sd::LongType*") LongPointer strides, int rank, @Cast("sd::LongType") long ews, @Cast("sd::LongType") long extras) { super((Pointer)null); allocate(type, order, shape, strides, rank, ews, extras); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") LongPointer shape,
                             @Cast("const sd::LongType*") LongPointer strides, int rank, @Cast("sd::LongType") long ews, @Cast("sd::LongType") long extras);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") LongBuffer shape,
                             @Cast("const sd::LongType*") LongBuffer strides, int rank, @Cast("sd::LongType") long ews, @Cast("sd::LongType") long extras) { super((Pointer)null); allocate(type, order, shape, strides, rank, ews, extras); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") LongBuffer shape,
                             @Cast("const sd::LongType*") LongBuffer strides, int rank, @Cast("sd::LongType") long ews, @Cast("sd::LongType") long extras);
  public ShapeDescriptor(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") long[] shape,
                             @Cast("const sd::LongType*") long[] strides, int rank, @Cast("sd::LongType") long ews, @Cast("sd::LongType") long extras) { super((Pointer)null); allocate(type, order, shape, strides, rank, ews, extras); }
  private native void allocate(@Cast("const sd::DataType") int type, byte order, @Cast("const sd::LongType*") long[] shape,
                             @Cast("const sd::LongType*") long[] strides, int rank, @Cast("sd::LongType") long ews, @Cast("sd::LongType") long extras);

  public ShapeDescriptor() { super((Pointer)null); allocate(); }
  private native void allocate();

  public native int rank();
  public native @Cast("sd::LongType") long ews();
  public native @Cast("sd::LongType") long arrLength();
  public native char order();
  public native @Cast("sd::DataType") int dataType();
  public native @Cast("bool") boolean isEmpty();
  public native @Cast("sd::LongType*") @StdVector LongPointer shape_strides();
  public native @Cast("const sd::LongType*") LongPointer stridesPtr();

  // returns minimal allocation length
  public native @Cast("sd::LongType") long allocLength();

  // returns Status for the correctness
  public native @Cast("sd::LongType") long validate();

  // we use default copy assignment operator
  public native @ByRef @Name("operator =") ShapeDescriptor put(@Const @ByRef ShapeDescriptor other);

  // we use default move assignment operator

  // equal to operator
  public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef ShapeDescriptor other);

  // less than operator
  public native @Cast("bool") @Name("operator <") boolean lessThan(@Const @ByRef ShapeDescriptor other);

  public native @Cast("sd::LongType*") LongPointer toShapeInfo();

  public native @ByVal ShapeDescriptor emptyDescriptor(@Cast("const sd::DataType") int type);
  public native @ByVal ShapeDescriptor scalarDescriptor(@Cast("const sd::DataType") int type);
  public native @ByVal ShapeDescriptor vectorDescriptor(@Cast("const sd::LongType") long length, @Cast("const sd::DataType") int type);

  // create Descriptor with padded buffer.
  public native @ByVal ShapeDescriptor paddedBufferDescriptor(@Cast("const sd::DataType") int type, byte order,
                                                  @Cast("sd::LongType*") @StdVector LongPointer shape,
                                                  @Cast("sd::LongType*") @StdVector LongPointer paddings);
  public native @ByVal ShapeDescriptor paddedBufferDescriptor(@Cast("const sd::DataType") int type, byte order,
                                                  @Cast("sd::LongType*") @StdVector LongBuffer shape,
                                                  @Cast("sd::LongType*") @StdVector LongBuffer paddings);
  public native @ByVal ShapeDescriptor paddedBufferDescriptor(@Cast("const sd::DataType") int type, byte order,
                                                  @Cast("sd::LongType*") @StdVector long[] shape,
                                                  @Cast("sd::LongType*") @StdVector long[] paddings);
}
  // namespace sd

// #ifndef __JAVACPP_HACK__

// #endif

// #endif  // DEV_TESTS_SHAPEDESCRIPTOR_H


// Parsed from array/TadDescriptor.h

/* ******************************************************************************
 *
 *
 * 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 [email protected]
//

// #ifndef DEV_TESTS_TADDESCRIPTOR_H
// #define DEV_TESTS_TADDESCRIPTOR_H

// #include 
@Namespace("sd") @NoOffset public static class TadDescriptor extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public TadDescriptor(Pointer p) { super(p); }

  public TadDescriptor(@Cast("const sd::LongType*") LongPointer originalShape, @Const IntPointer dimensions, int length,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/) { super((Pointer)null); allocate(originalShape, dimensions, length, keepUnitiesInShape); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer originalShape, @Const IntPointer dimensions, int length,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/);
  public TadDescriptor(@Cast("const sd::LongType*") LongPointer originalShape, @Const IntPointer dimensions, int length) { super((Pointer)null); allocate(originalShape, dimensions, length); }
  private native void allocate(@Cast("const sd::LongType*") LongPointer originalShape, @Const IntPointer dimensions, int length);
  public TadDescriptor(@Cast("const sd::LongType*") LongBuffer originalShape, @Const IntBuffer dimensions, int length,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/) { super((Pointer)null); allocate(originalShape, dimensions, length, keepUnitiesInShape); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer originalShape, @Const IntBuffer dimensions, int length,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/);
  public TadDescriptor(@Cast("const sd::LongType*") LongBuffer originalShape, @Const IntBuffer dimensions, int length) { super((Pointer)null); allocate(originalShape, dimensions, length); }
  private native void allocate(@Cast("const sd::LongType*") LongBuffer originalShape, @Const IntBuffer dimensions, int length);
  public TadDescriptor(@Cast("const sd::LongType*") long[] originalShape, @Const int[] dimensions, int length,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/) { super((Pointer)null); allocate(originalShape, dimensions, length, keepUnitiesInShape); }
  private native void allocate(@Cast("const sd::LongType*") long[] originalShape, @Const int[] dimensions, int length,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/);
  public TadDescriptor(@Cast("const sd::LongType*") long[] originalShape, @Const int[] dimensions, int length) { super((Pointer)null); allocate(originalShape, dimensions, length); }
  private native void allocate(@Cast("const sd::LongType*") long[] originalShape, @Const int[] dimensions, int length);
  public TadDescriptor(@Const @ByRef ShapeDescriptor descriptor, @StdVector IntPointer dimensions,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/) { super((Pointer)null); allocate(descriptor, dimensions, keepUnitiesInShape); }
  private native void allocate(@Const @ByRef ShapeDescriptor descriptor, @StdVector IntPointer dimensions,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/);
  public TadDescriptor(@Const @ByRef ShapeDescriptor descriptor, @StdVector IntPointer dimensions) { super((Pointer)null); allocate(descriptor, dimensions); }
  private native void allocate(@Const @ByRef ShapeDescriptor descriptor, @StdVector IntPointer dimensions);
  public TadDescriptor(@Const @ByRef ShapeDescriptor descriptor, @StdVector IntBuffer dimensions,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/) { super((Pointer)null); allocate(descriptor, dimensions, keepUnitiesInShape); }
  private native void allocate(@Const @ByRef ShapeDescriptor descriptor, @StdVector IntBuffer dimensions,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/);
  public TadDescriptor(@Const @ByRef ShapeDescriptor descriptor, @StdVector IntBuffer dimensions) { super((Pointer)null); allocate(descriptor, dimensions); }
  private native void allocate(@Const @ByRef ShapeDescriptor descriptor, @StdVector IntBuffer dimensions);
  public TadDescriptor(@Const @ByRef ShapeDescriptor descriptor, @StdVector int[] dimensions,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/) { super((Pointer)null); allocate(descriptor, dimensions, keepUnitiesInShape); }
  private native void allocate(@Const @ByRef ShapeDescriptor descriptor, @StdVector int[] dimensions,
                           @Cast("const bool") boolean keepUnitiesInShape/*=false*/);
  public TadDescriptor(@Const @ByRef ShapeDescriptor descriptor, @StdVector int[] dimensions) { super((Pointer)null); allocate(descriptor, dimensions); }
  private native void allocate(@Const @ByRef ShapeDescriptor descriptor, @StdVector int[] dimensions);

  // we use default copy assignment operator
// #ifndef __NEC__
  // NCC has issues with copy constructors
  public native @ByRef @Name("operator =") TadDescriptor put(@Const @ByRef TadDescriptor other);
  // we use default move assignment operator
  public TadDescriptor(@Const @ByRef TadDescriptor other) { super((Pointer)null); allocate(other); }
  private native void allocate(@Const @ByRef TadDescriptor other);
// #endif

// #ifdef __NEC__
// #endif

  // equal to operator
  public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef TadDescriptor other);

  // less than operator
  public native @Cast("bool") @Name("operator <") boolean lessThan(@Const @ByRef TadDescriptor other);

  public native @StdVector IntPointer axis();
  public native @ByRef ShapeDescriptor originalShape();
  public native @Const @ByRef ShapeDescriptor originalShapeConst();
  public native @Cast("bool") boolean areUnitiesinShape();
}
  // namespace sd

// #ifndef __JAVACPP_HACK__

// #endif

// #endif  // DEV_TESTS_TADDESCRIPTOR_H


// Parsed from helpers/DebugInfo.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by GS aka shugeo  on 3/12/19.
//

// #ifndef LIBND4J__DEBUG_INFO_HELPER__H
// #define LIBND4J__DEBUG_INFO_HELPER__H

// #include 
// #include $
// #include 
// #include 

// #include 

// #ifdef __CUDACC__

// #endif
@Namespace("sd") public static class DebugInfo extends Pointer {
    static { Loader.load(); }
    /** Default native constructor. */
    public DebugInfo() { super((Pointer)null); allocate(); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public DebugInfo(long size) { super((Pointer)null); allocateArray(size); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DebugInfo(Pointer p) { super(p); }
    private native void allocate();
    private native void allocateArray(long size);
    @Override public DebugInfo position(long position) {
        return (DebugInfo)super.position(position);
    }
    @Override public DebugInfo getPointer(long i) {
        return new DebugInfo((Pointer)this).offsetAddress(i);
    }

  public native double _minValue(); public native DebugInfo _minValue(double setter);
  public native double _maxValue(); public native DebugInfo _maxValue(double setter);
  public native double _meanValue(); public native DebugInfo _meanValue(double setter);
  public native double _stdDevValue(); public native DebugInfo _stdDevValue(double setter);
  public native @Cast("sd::LongType") long _zeroCount(); public native DebugInfo _zeroCount(long setter);
  public native @Cast("sd::LongType") long _positiveCount(); public native DebugInfo _positiveCount(long setter);
  public native @Cast("sd::LongType") long _negativeCount(); public native DebugInfo _negativeCount(long setter);
  public native @Cast("sd::LongType") long _infCount(); public native DebugInfo _infCount(long setter);
  public native @Cast("sd::LongType") long _nanCount(); public native DebugInfo _nanCount(long setter);
}

@Namespace("sd") public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef DebugInfo first, @Const @ByRef DebugInfo second);

  // namespace sd

// #endif  // LIBND4J_DEBUGHELPER_H


// Parsed from ops/declarable/CustomOperations.h

/* ******************************************************************************
 *
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 *  See the NOTICE file distributed with this work for additional
 *  information regarding copyright ownership.
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by raver119 on 07.10.2017.
//

// #ifndef LIBND4J_CUSTOMOPERATIONS_H
// #define LIBND4J_CUSTOMOPERATIONS_H
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
// #include 
     @Namespace("sd") public static class _loader extends Pointer {
         static { Loader.load(); }
         /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
         public _loader(Pointer p) { super(p); }
         /** Native array allocator. Access with {@link Pointer#position(long)}. */
         public _loader(long size) { super((Pointer)null); allocateArray(size); }
         private native void allocateArray(long size);
         @Override public _loader position(long position) {
             return (_loader)super.position(position);
         }
         @Override public _loader getPointer(long i) {
             return new _loader((Pointer)this).offsetAddress(i);
         }
     
         public _loader() { super((Pointer)null); allocate(); }
         private native void allocate();
}

// logic ops
// #if NOT_EXCLUDED(OP_Switch)
@Namespace("sd::ops") public static class Switch extends DeclarableOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public Switch(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public Switch(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public Switch position(long position) {
        return (Switch)super.position(position);
    }
    @Override public Switch getPointer(long i) {
        return new Switch((Pointer)this).offsetAddress(i);
    }

    public Switch() { super((Pointer)null); allocate(); }
    private native void allocate();
    public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
  }
// #endif
// #if NOT_EXCLUDED(OP_While)
@Namespace("sd::ops") public static class While extends LogicOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public While(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public While(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public While position(long position) {
        return (While)super.position(position);
    }
    @Override public While getPointer(long i) {
        return new While((Pointer)this).offsetAddress(i);
    }

    public While() { super((Pointer)null); allocate(); }
    private native void allocate();
  }
// #endif
// #if NOT_EXCLUDED(OP_Scope)
@Namespace("sd::ops") public static class Scope extends LogicOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public Scope(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public Scope(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public Scope position(long position) {
        return (Scope)super.position(position);
    }
    @Override public Scope getPointer(long i) {
        return new Scope((Pointer)this).offsetAddress(i);
    }

    public Scope() { super((Pointer)null); allocate(); }
    private native void allocate();
  }
// #endif
// #if NOT_EXCLUDED(OP_Conditional)
@Namespace("sd::ops") public static class Conditional extends LogicOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public Conditional(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public Conditional(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public Conditional position(long position) {
        return (Conditional)super.position(position);
    }
    @Override public Conditional getPointer(long i) {
        return new Conditional((Pointer)this).offsetAddress(i);
    }

    public Conditional() { super((Pointer)null); allocate(); }
    private native void allocate();
  }
// #endif
// #if NOT_EXCLUDED(OP_Return)
@Namespace("sd::ops") public static class Return extends LogicOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public Return(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public Return(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public Return position(long position) {
        return (Return)super.position(position);
    }
    @Override public Return getPointer(long i) {
        return new Return((Pointer)this).offsetAddress(i);
    }

    public Return() { super((Pointer)null); allocate(); }
    private native void allocate();
  }
// #endif

/**
 * This operations exposes given arguments as it's own outputs, but does it only once.
 * Subsequent calls will be served directly by this op.
 *
 * PLEASE NOTE: This operation is internal graph operation, and shouldn't be used directly usually.
 */
// #if NOT_EXCLUDED(OP_expose)
@Namespace("sd::ops") public static class expose extends DeclarableCustomOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public expose(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public expose(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public expose position(long position) {
        return (expose)super.position(position);
    }
    @Override public expose getPointer(long i) {
        return new expose((Pointer)this).offsetAddress(i);
    }

    public expose() { super((Pointer)null); allocate(); }
    private native void allocate();
    public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
  }
// #endif

// #if NOT_EXCLUDED(OP_invoke)
@Namespace("sd::ops") public static class invoke extends DeclarableCustomOp {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public invoke(Pointer p) { super(p); }
    /** Native array allocator. Access with {@link Pointer#position(long)}. */
    public invoke(long size) { super((Pointer)null); allocateArray(size); }
    private native void allocateArray(long size);
    @Override public invoke position(long position) {
        return (invoke)super.position(position);
    }
    @Override public invoke getPointer(long i) {
        return new invoke((Pointer)this).offsetAddress(i);
    }

    public invoke() { super((Pointer)null); allocate(); }
    private native void allocate();
    public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block);
  }
// #endif
  // namespace ops
  // namespace sd

// #endif  // LIBND4J_CUSTOMOPERATIONS_H


// Parsed from build_info.h

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

// #ifndef LIBND4J_BUILD_INFO_H
// #define LIBND4J_BUILD_INFO_H

// #include 

// #ifdef __cplusplus
// #endif

public native @Cast("char*") String buildInfo();

// #ifdef __cplusplus
// #endif

// #endif


}
$