// Copyright (c) 2019 by the SciSharp Team

// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using Python.Runtime;

using Numpy.Models;

namespace Numpy

{

public partial class NumPy

{

/// <summary>

/// Return a new array of given shape and type, without initializing entries.<br></br>

///

/// Notes

///

/// empty, unlike zeros, does not set the array values to zero,

/// and may therefore be marginally faster.<br></br>

/// On the other hand, it requires

/// the user to manually set all the values in the array, and should be

/// used with caution.

/// </summary>

/// <param name="shape">

/// Shape of the empty array, e.g., (2, 3) or 2.

/// </param>

/// <param name="dtype">

/// Desired output data-type for the array, e.g, numpy.int8. Default is

/// numpy.float64.

/// </param>

/// <param name="order">

/// Whether to store multi-dimensional data in row-major

/// (C-style) or column-major (Fortran-style) order in

/// memory.

/// </param>

/// <returns>

/// Array of uninitialized (arbitrary) data of the given shape, dtype, and

/// order.<br></br>

/// Object arrays will be initialized to None.

/// </returns>

public NDarray empty(Shape shape, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

shape,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("empty", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return a new array with the same shape and type as a given array.<br></br>

///

/// Notes

///

/// This function does not initialize the returned array; to do that use

/// zeros_like or ones_like instead.<br></br>

/// It may be marginally faster than

/// the functions that do set the array values.

/// </summary>

/// <param name="prototype">

/// The shape and data-type of prototype define these same attributes

/// of the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if prototype is Fortran

/// contiguous, ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of prototype

/// as closely as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of uninitialized (arbitrary) data with the same

/// shape and type as prototype.

/// </returns>

public NDarray empty_like(NDarray prototype, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

prototype,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("empty_like", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return a new array with the same shape and type as a given array.<br></br>

///

/// Notes

///

/// This function does not initialize the returned array; to do that use

/// zeros_like or ones_like instead.<br></br>

/// It may be marginally faster than

/// the functions that do set the array values.

/// </summary>

/// <param name="prototype">

/// The shape and data-type of prototype define these same attributes

/// of the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if prototype is Fortran

/// contiguous, ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of prototype

/// as closely as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of uninitialized (arbitrary) data with the same

/// shape and type as prototype.

/// </returns>

public NDarray<T> empty_like<T>(T[] prototype, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(prototype),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("empty_like", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Return a new array with the same shape and type as a given array.<br></br>

///

/// Notes

///

/// This function does not initialize the returned array; to do that use

/// zeros_like or ones_like instead.<br></br>

/// It may be marginally faster than

/// the functions that do set the array values.

/// </summary>

/// <param name="prototype">

/// The shape and data-type of prototype define these same attributes

/// of the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if prototype is Fortran

/// contiguous, ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of prototype

/// as closely as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of uninitialized (arbitrary) data with the same

/// shape and type as prototype.

/// </returns>

public NDarray<T> empty_like<T>(T[,] prototype, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(prototype),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("empty_like", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Return a 2-D array with ones on the diagonal and zeros elsewhere.

/// </summary>

/// <param name="N">

/// Number of rows in the output.

/// </param>

/// <param name="M">

/// Number of columns in the output.<br></br>

/// If None, defaults to N.

/// </param>

/// <param name="k">

/// Index of the diagonal: 0 (the default) refers to the main diagonal,

/// a positive value refers to an upper diagonal, and a negative value

/// to a lower diagonal.

/// </param>

/// <param name="dtype">

/// Data-type of the returned array.

/// </param>

/// <param name="order">

/// Whether the output should be stored in row-major (C-style) or

/// column-major (Fortran-style) order in memory.

/// </param>

/// <returns>

/// An array where all elements are equal to zero, except for the k-th

/// diagonal, whose values are equal to one.

/// </returns>

public NDarray eye(int N, int? M = null, int? k = 0, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

N,

});

var kwargs=new PyDict();

if (M!=null) kwargs["M"]=ToPython(M);

if (k!=0) kwargs["k"]=ToPython(k);

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("eye", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return the identity array.<br></br>

///

/// The identity array is a square array with ones on

/// the main diagonal.

/// </summary>

/// <param name="n">

/// Number of rows (and columns) in n x n output.

/// </param>

/// <param name="dtype">

/// Data-type of the output.<br></br>

/// Defaults to float.

/// </param>

/// <returns>

/// n x n array with its main diagonal set to one,

/// and all other elements 0.

/// </returns>

public NDarray identity(int n, Dtype dtype = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

n,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

dynamic py = __self__.InvokeMethod("identity", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return a new array of given shape and type, filled with ones.

/// </summary>

/// <param name="shape">

/// Shape of the new array, e.g., (2, 3) or 2.

/// </param>

/// <param name="dtype">

/// The desired data-type for the array, e.g., numpy.int8. Default is

/// numpy.float64.

/// </param>

/// <param name="order">

/// Whether to store multi-dimensional data in row-major

/// (C-style) or column-major (Fortran-style) order in

/// memory.

/// </param>

/// <returns>

/// Array of ones with the given shape, dtype, and order.

/// </returns>

public NDarray ones(Shape shape, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

shape,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("ones", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return an array of ones with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of ones with the same shape and type as a.

/// </returns>

public NDarray ones_like(NDarray a, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("ones_like", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return an array of ones with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of ones with the same shape and type as a.

/// </returns>

public NDarray<T> ones_like<T>(T[] a, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("ones_like", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Return an array of ones with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of ones with the same shape and type as a.

/// </returns>

public NDarray<T> ones_like<T>(T[,] a, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("ones_like", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Return a new array of given shape and type, filled with zeros.

/// </summary>

/// <param name="shape">

/// Shape of the new array, e.g., (2, 3) or 2.

/// </param>

/// <param name="dtype">

/// The desired data-type for the array, e.g., numpy.int8. Default is

/// numpy.float64.

/// </param>

/// <param name="order">

/// Whether to store multi-dimensional data in row-major

/// (C-style) or column-major (Fortran-style) order in

/// memory.

/// </param>

/// <returns>

/// Array of zeros with the given shape, dtype, and order.

/// </returns>

public NDarray zeros(Shape shape, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

shape,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("zeros", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return an array of zeros with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of zeros with the same shape and type as a.

/// </returns>

public NDarray zeros_like(NDarray a, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("zeros_like", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return an array of zeros with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of zeros with the same shape and type as a.

/// </returns>

public NDarray<T> zeros_like<T>(T[] a, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("zeros_like", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Return an array of zeros with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of zeros with the same shape and type as a.

/// </returns>

public NDarray<T> zeros_like<T>(T[,] a, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("zeros_like", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Return a new array of given shape and type, filled with fill_value.

/// </summary>

/// <param name="shape">

/// Shape of the new array, e.g., (2, 3) or 2.

/// </param>

/// <param name="fill_value">

/// Fill value.

/// </param>

/// <param name="order">

/// Whether to store multidimensional data in C- or Fortran-contiguous

/// (row- or column-wise) order in memory.

/// </param>

/// <returns>

/// Array of fill_value with the given shape, dtype, and order.

/// </returns>

public NDarray full(Shape shape, ValueType fill_value, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

shape,

fill_value,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("full", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return a full array with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="fill_value">

/// Fill value.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of fill_value with the same shape and type as a.

/// </returns>

public NDarray full_like(NDarray a, ValueType fill_value, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

fill_value,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("full_like", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return a full array with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="fill_value">

/// Fill value.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of fill_value with the same shape and type as a.

/// </returns>

public NDarray<T> full_like<T>(T[] a, ValueType fill_value, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

fill_value,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("full_like", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Return a full array with the same shape and type as a given array.

/// </summary>

/// <param name="a">

/// The shape and data-type of a define these same attributes of

/// the returned array.

/// </param>

/// <param name="fill_value">

/// Fill value.

/// </param>

/// <param name="dtype">

/// Overrides the data type of the result.

/// </param>

/// <param name="order">

/// Overrides the memory layout of the result.<br></br>

/// ‘C’ means C-order,

/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,

/// ‘C’ otherwise.<br></br>

/// ‘K’ means match the layout of a as closely

/// as possible.

/// </param>

/// <param name="subok">

/// If True, then the newly created array will use the sub-class

/// type of ‘a’, otherwise it will be a base-class array.<br></br>

/// Defaults

/// to True.

/// </param>

/// <returns>

/// Array of fill_value with the same shape and type as a.

/// </returns>

public NDarray<T> full_like<T>(T[,] a, ValueType fill_value, Dtype dtype = null, string order = null, bool? subok = true)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

fill_value,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

if (subok!=true) kwargs["subok"]=ToPython(subok);

dynamic py = __self__.InvokeMethod("full_like", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Convert the input to an array.

/// </summary>

/// <param name="a">

/// Input data, in any form that can be converted to an array.<br></br>

/// This

/// includes lists, lists of tuples, tuples, tuples of tuples, tuples

/// of lists and ndarrays.

/// </param>

/// <param name="dtype">

/// By default, the data-type is inferred from the input data.

/// </param>

/// <param name="order">

/// Whether to use row-major (C-style) or

/// column-major (Fortran-style) memory representation.<br></br>

///

/// Defaults to ‘C’.

/// </param>

/// <returns>

/// Array interpretation of a.<br></br>

/// No copy is performed if the input

/// is already an ndarray with matching dtype and order.<br></br>

/// If a is a

/// subclass of ndarray, a base class ndarray is returned.

/// </returns>

public NDarray asarray(NDarray a, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("asarray", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Convert the input to an array.

/// </summary>

/// <param name="a">

/// Input data, in any form that can be converted to an array.<br></br>

/// This

/// includes lists, lists of tuples, tuples, tuples of tuples, tuples

/// of lists and ndarrays.

/// </param>

/// <param name="dtype">

/// By default, the data-type is inferred from the input data.

/// </param>

/// <param name="order">

/// Whether to use row-major (C-style) or

/// column-major (Fortran-style) memory representation.<br></br>

///

/// Defaults to ‘C’.

/// </param>

/// <returns>

/// Array interpretation of a.<br></br>

/// No copy is performed if the input

/// is already an ndarray with matching dtype and order.<br></br>

/// If a is a

/// subclass of ndarray, a base class ndarray is returned.

/// </returns>

public NDarray<T> asarray<T>(T[] a, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("asarray", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Convert the input to an array.

/// </summary>

/// <param name="a">

/// Input data, in any form that can be converted to an array.<br></br>

/// This

/// includes lists, lists of tuples, tuples, tuples of tuples, tuples

/// of lists and ndarrays.

/// </param>

/// <param name="dtype">

/// By default, the data-type is inferred from the input data.

/// </param>

/// <param name="order">

/// Whether to use row-major (C-style) or

/// column-major (Fortran-style) memory representation.<br></br>

///

/// Defaults to ‘C’.

/// </param>

/// <returns>

/// Array interpretation of a.<br></br>

/// No copy is performed if the input

/// is already an ndarray with matching dtype and order.<br></br>

/// If a is a

/// subclass of ndarray, a base class ndarray is returned.

/// </returns>

public NDarray<T> asarray<T>(T[,] a, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("asarray", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Convert the input to an ndarray, but pass ndarray subclasses through.

/// </summary>

/// <param name="a">

/// Input data, in any form that can be converted to an array.<br></br>

/// This

/// includes scalars, lists, lists of tuples, tuples, tuples of tuples,

/// tuples of lists, and ndarrays.

/// </param>

/// <param name="dtype">

/// By default, the data-type is inferred from the input data.

/// </param>

/// <param name="order">

/// Whether to use row-major (C-style) or column-major

/// (Fortran-style) memory representation.<br></br>

/// Defaults to ‘C’.

/// </param>

/// <returns>

/// Array interpretation of a.<br></br>

/// If a is an ndarray or a subclass

/// of ndarray, it is returned as-is and no copy is performed.

/// </returns>

public NDarray asanyarray(NDarray a, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("asanyarray", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Convert the input to an ndarray, but pass ndarray subclasses through.

/// </summary>

/// <param name="a">

/// Input data, in any form that can be converted to an array.<br></br>

/// This

/// includes scalars, lists, lists of tuples, tuples, tuples of tuples,

/// tuples of lists, and ndarrays.

/// </param>

/// <param name="dtype">

/// By default, the data-type is inferred from the input data.

/// </param>

/// <param name="order">

/// Whether to use row-major (C-style) or column-major

/// (Fortran-style) memory representation.<br></br>

/// Defaults to ‘C’.

/// </param>

/// <returns>

/// Array interpretation of a.<br></br>

/// If a is an ndarray or a subclass

/// of ndarray, it is returned as-is and no copy is performed.

/// </returns>

public NDarray<T> asanyarray<T>(T[] a, Dtype dtype = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

SharpToSharp<NDarray>(a),

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("asanyarray", pyargs, kwargs);

return ToCsharp<NDarray<T>>(py);

}

/// <summary>

/// Convert the input to an ndarray, but pass ndarray subclasses through.

/// </summary>

/// <param name="a">

/// Input data, in any form that can be converted to an array.<br></br>

/// This

/// includes scalars, lists, lists of tuples, tuples, tuples of tuples,

/// tuples of lists, and ndarrays.

/// </param>

/// <param name="dtype">

/// By default, the data-type is inferred from the input data.

/// </param>

/// <param name="order">

/// Whether to use row-major (C-style) or column-major

/// (Fortran-style) memory representation.<br></br>

/// Defaults to ‘C’.

/// </param>

/// <returns>

/// Array interpretation of a.<br></br>

/// If a is an ndarray or a subclass

/// of ndarray, it is returned as-is and no copy is performed.