<code>optional .tensorflow.CollectionDef.Int64List int64_list = 3;</code>
977419
public org.tensorflow.framework.CollectionDef.Int64List getInt64List() {
    if (kindCase_ == 3) {
       return (org.tensorflow.framework.CollectionDef.Int64List) kind_;
    }
    return org.tensorflow.framework.CollectionDef.Int64List.getDefaultInstance();
  }
980294
function __deserializeInt64(buffer, start, options) {
	let step = 4;
	let length = 2;
	let end = start + (step * length);
	let dataView = new DataView(buffer);
	let dataArray = [];
	for (let i = start; i < end; i += step) {
		dataArray.push(dataView.getUint32(i, true));
	}
	let data = new Int64(new Uint32Array(dataArray));
	return { anchor: end, value: data };
}
1207217
public static Tuple3<List<Point2D_F64>,List<Point2D_F64>,List<Point2D_F64>> split3(List<AssociatedTriple> input )
	{
		List<Point2D_F64> list1 = new ArrayList<>();
		List<Point2D_F64> list2 = new ArrayList<>();
		List<Point2D_F64> list3 = new ArrayList<>();

		for (int i = 0; i < input.size(); i++) {
			list1.add( input.get(i).p1 );
			list2.add( input.get(i).p2 );
			list3.add( input.get(i).p3 );
		}

		return new Tuple3<>(list1,list2,list3);
	}
114401
public ISynchronizationPoint<? extends Exception> specifyValue(
		SerializationContext context, TypeDefinition typeDef, List<SerializationRule> rules
	) {
		for (SerializationRule rule : rules)
			typeDef = rule.getDeserializationType(typeDef, context);
		
		Class<?> type = typeDef.getBase();
		
		if (type.isArray()) {
			if (byte[].class.equals(type))
				return specifyByteArrayValue(context, rules);
			Class<?> elementType = type.getComponentType();
			CollectionContext ctx = new CollectionContext(context, null, typeDef, new TypeDefinition(elementType));
			return specifyCollectionValue(ctx, rules);
		}
		
		if (boolean.class.equals(type))
			return specifyBooleanValue(context, false);
		if (Boolean.class.equals(type))
			return specifyBooleanValue(context, true);
		
		if (byte.class.equals(type))
			return specifyNumericValue(context, Byte.class, false, Byte.valueOf(Byte.MIN_VALUE), Byte.valueOf(Byte.MAX_VALUE));
		if (Byte.class.equals(type))
			return specifyNumericValue(context, Byte.class, true, Byte.valueOf(Byte.MIN_VALUE), Byte.valueOf(Byte.MAX_VALUE));
		if (short.class.equals(type))
			return specifyNumericValue(context, Short.class, false, Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE));
		if (Short.class.equals(type))
			return specifyNumericValue(context, Short.class, true, Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE));
		if (int.class.equals(type))
			return specifyNumericValue(context, Integer.class, false,
				Integer.valueOf(Integer.MIN_VALUE), Integer.valueOf(Integer.MAX_VALUE));
		if (Integer.class.equals(type))
			return specifyNumericValue(context, Integer.class, true,
				Integer.valueOf(Integer.MIN_VALUE), Integer.valueOf(Integer.MAX_VALUE));
		if (long.class.equals(type))
			return specifyNumericValue(context, Long.class, false, Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MAX_VALUE));
		if (Long.class.equals(type))
			return specifyNumericValue(context, Long.class, true, Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MAX_VALUE));
		if (float.class.equals(type) ||
			double.class.equals(type) ||
			Number.class.isAssignableFrom(type))
			return specifyNumericValue(context, type, !type.isPrimitive(), null, null);

		if (char.class.equals(type))
			return specifyCharacterValue(context, false);
		if (Character.class.equals(type))
			return specifyCharacterValue(context, true);
		
		if (CharSequence.class.isAssignableFrom(type))
			return specifyStringValue(context, typeDef);
		
		if (type.isEnum())
			return specifyEnumValue(context, typeDef);

		if (Collection.class.isAssignableFrom(type)) {
			TypeDefinition elementType;
			if (typeDef.getParameters().isEmpty())
				elementType = null;
			else
				elementType = typeDef.getParameters().get(0);
			CollectionContext ctx = new CollectionContext(context, null, typeDef, elementType);
			return specifyCollectionValue(ctx, rules);
		}

		if (Map.class.isAssignableFrom(type))
			return specifyMapValue(context, typeDef, rules);
		
		if (InputStream.class.isAssignableFrom(type))
			return specifyInputStreamValue(context, rules);
		
		if (IO.Readable.class.isAssignableFrom(type))
			return specifyIOReadableValue(context, rules);
		
		return specifyObjectValue(context, typeDef, rules);
	}
323015
public org.tensorflow.framework.CollectionDef.FloatList getFloatList() {
    if (kindCase_ == 4) {
       return (org.tensorflow.framework.CollectionDef.FloatList) kind_;
    }
    return org.tensorflow.framework.CollectionDef.FloatList.getDefaultInstance();
  }
559267
public DataType nd4jTypeFromOnnxType(OnnxProto3.TensorProto.DataType dataType) {
        switch (dataType) {
            case DOUBLE: return DataType.DOUBLE;
            case FLOAT: return DataType.FLOAT;
            case FLOAT16: return DataType.HALF;
            case INT32:
            case INT64: return DataType.INT;
            default: return DataType.UNKNOWN;
        }
    }
118035
public static final DenseMatrix64F get141Matrix(int order)
    {
        if (order < 2)
        {
            throw new IllegalArgumentException("order has to be at least 2 for 1 4 1 matrix");
        }
        double[] data = new double[order*order];
        for (int row=0;row<order;row++)
        {
            for (int col=0;col<order;col++)
            {
                int index = row*order+col;
                if (row == col)
                {
                    data[index] = 4;
                }
                else
                {
                    if (Math.abs(row-col) == 1)
                    {
                        data[index] = 1;
                    }
                    else
                    {
                        data[index] = 0;
                    }
                }
            }
        }
        return new DenseMatrix64F(order, order, true, data);
    }
918845
public org.tensorflow.framework.AttrValue.ListValue getList() {
    if (valueCase_ == 1) {
       return (org.tensorflow.framework.AttrValue.ListValue) value_;
    }
    return org.tensorflow.framework.AttrValue.ListValue.getDefaultInstance();
  }
202855
public org.tensorflow.framework.CostGraphDef.NodeOrBuilder getNodeOrBuilder(
      int index) {
    return node_.get(index);
  }
763328
private long numDepthWiseParams(SeparableConvolution2D layerConf) {
        int[] kernel = layerConf.getKernelSize();
        val nIn = layerConf.getNIn();
        val depthMultiplier = layerConf.getDepthMultiplier();

        return nIn * depthMultiplier * kernel[0] * kernel[1];
    }
681508
public static List<Integer> asList(final IntTuple t)
    {
        if (t == null)
        {
            throw new NullPointerException("The tuple may not be null");
        }
        return new AbstractList<Integer>()
        {
            @Override
            public Integer get(int index)
            {
                return t.get(index);
            }

            @Override
            public int size()
            {
                return t.getSize();
            }
        };
    }
618104
@Override
    public long numParams(boolean backwards) {
        int length = 0;
        for (int i = 0; i < layers.length; i++)
            length += layers[i].numParams(backwards);

        return length;
    }
1104362
public TF_Tensor tensorFromNDArray(INDArray ndArray) {
       if(ndArray == null) {
           throw new IllegalArgumentException("NDArray must not be null!");
       }
        //we infer data type from the ndarray.databuffer()
        //for now we throw an exception
        if(ndArray.data() == null) {
           throw new IllegalArgumentException("Unable to infer data type from null databuffer");
       }

        if(ndArray.isView() || ndArray.ordering() != 'c') {
            ndArray = ndArray.dup('c');
        }


        long[] ndShape = ndArray.shape();
        long[] tfShape = new long[ndShape.length];
        System.arraycopy(ndShape, 0, tfShape, 0, ndShape.length);

        int type;
        DataBuffer data = ndArray.data();
        DataType dataType = data.dataType();
        switch (dataType) {
            case DOUBLE: type = DT_DOUBLE; break;
            case FLOAT:  type = DT_FLOAT;  break;
            case INT:    type = DT_INT32;  break;
            case HALF:   type = DT_HALF;   break;
            case COMPRESSED:
                CompressedDataBuffer compressedData = (CompressedDataBuffer)data;
                CompressionDescriptor desc = compressedData.getCompressionDescriptor();
                String algo = desc.getCompressionAlgorithm();
                switch (algo) {
                    case "FLOAT16": type = DT_HALF;   break;
                    case "INT8":    type = DT_INT8;   break;
                    case "UINT8":   type = DT_UINT8;  break;
                    case "INT16":   type = DT_INT16;  break;
                    case "UINT16":  type = DT_UINT16; break;
                    default: throw new IllegalArgumentException("Unsupported compression algorithm: " + algo);
                }
                break;
            case LONG: type = DT_INT64; break;
            case UTF8: type = DT_STRING; break;
            default: throw new IllegalArgumentException("Unsupported data type: " + dataType);
        }

        try {
            Nd4j.getAffinityManager().ensureLocation(ndArray, AffinityManager.Location.HOST);
        } catch (Exception e) {
            // ND4J won't let us access compressed data in GPU memory, so we'll leave TensorFlow do the conversion instead
            ndArray.getDouble(0); // forces decompression and data copy to host
            data = ndArray.data();
            dataType = data.dataType();
            switch (dataType) {
                case DOUBLE: type = DT_DOUBLE; break;
                case FLOAT:  type = DT_FLOAT;  break;
                case INT:    type = DT_INT32;  break;
                case LONG:   type = DT_INT64;  break;
                case UTF8: type = DT_STRING; break;
                default: throw new IllegalArgumentException("Unsupported data type: " + dataType);
            }
        }


        LongPointer longPointer = new LongPointer(tfShape);
        TF_Tensor tf_tensor = null;

        if (type == DT_STRING) {
            long size = 0;
            long length = ndArray.length();
            BytePointer[] strings = new BytePointer[(int)length];
            for (int i = 0; i < length; i++) {
                strings[i] = new BytePointer(ndArray.getString(i));
                size += TF_StringEncodedSize(strings[i].capacity());
            }
            tf_tensor = TF_AllocateTensor(
                    type,
                    longPointer,
                    tfShape.length,
                    8 * length + size);

            long offset = 0;
            BytePointer tf_data = new BytePointer(TF_TensorData(tf_tensor)).capacity(TF_TensorByteSize(tf_tensor));
            TF_Status status = TF_NewStatus();
            for (int i = 0; i < length; i++) {
                tf_data.position(8 * i).putLong(offset);
                offset += TF_StringEncode(strings[i], strings[i].capacity() - 1, tf_data.position(8 * length + offset), tf_data.capacity() - tf_data.position(), status);
                if (TF_GetCode(status) != TF_OK) {
                    throw new IllegalStateException("ERROR: Unable to convert tensor " + TF_Message(status).getString());
                }
            }
            TF_DeleteStatus(status);
        } else {
            tf_tensor = TF_NewTensor(
                    type,
                    longPointer,
                    tfShape.length,
                    data.pointer(),
                    data.length() * data.getElementSize(),
                    calling,null);
        }

        return tf_tensor;

    }
753654
public <M extends DMatrix>M read64() throws IOException {
        List<String> words = extractWords();

        if( words.size() == 3 ) {
            int numRows = Integer.parseInt(words.get(0));
            int numCols = Integer.parseInt(words.get(1));
            boolean real = words.get(2).compareToIgnoreCase("real") == 0;

            if (numRows < 0 || numCols < 0)
                throw new IOException("Invalid number of rows and/or columns: " + numRows + " " + numCols);

            if (real)
                return (M) readDDRM(numRows, numCols);
            else
                return (M) readZDRM(numRows, numCols);
        } else if ( words.size() == 4 ) {
            int numRows = Integer.parseInt(words.get(0));
            int numCols = Integer.parseInt(words.get(1));
            int length = Integer.parseInt(words.get(2));
            boolean real = words.get(3).compareToIgnoreCase("real") == 0;

            if (numRows < 0 || numCols < 0)
                throw new IOException("Invalid number of rows and/or columns: " + numRows + " " + numCols);

            if (real)
                return (M) readDSTR(numRows, numCols, length);
            else
                throw new IllegalArgumentException("Sparse complex not yet supported");
        } else {
            throw new IOException("Unexpected number of words on the first line. Found "+words.size());
        }
    }
1068594
def _int64_feature(value):
  """"""
  if not isinstance(value, list):
    value = [value]
  return tf.train.Feature(int64_list=tf.train.Int64List(value=value))
719488
public org.tensorflow.framework.KernelDef.AttrConstraintOrBuilder getConstraintOrBuilder(
      int index) {
    return constraint_.get(index);
  }
342370
public void insert_u64(final long argin) {
	final long[] values = new long[1];
	values[0] = argin;
	attrval.r_dim.dim_x = 1;
	attrval.r_dim.dim_y = 0;
	DevVarULong64ArrayHelper.insert(attrval.value, values);
    }