// 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;
using Python.Included;
namespace Numpy
{
public static partial class np
{
///
/// Return a new array of given shape and type, without initializing entries.
///
/// Notes
///
/// empty, unlike zeros, does not set the array values to zero,
/// and may therefore be marginally faster.
/// On the other hand, it requires
/// the user to manually set all the values in the array, and should be
/// used with caution.
///
///
/// Shape of the empty array, e.g., (2, 3) or 2.
///
///
/// Desired output data-type for the array, e.g, numpy.int8. Default is
/// numpy.float64.
///
///
/// Whether to store multi-dimensional data in row-major
/// (C-style) or column-major (Fortran-style) order in
/// memory.
///
///
/// Array of uninitialized (arbitrary) data of the given shape, dtype, and
/// order.
/// Object arrays will be initialized to None.
///
public static NDarray empty(Shape shape, Dtype dtype = null, string order = null)
=> NumPy.Instance.empty(shape, dtype:dtype, order:order);
///
/// Return a new array with the same shape and type as a given array.
///
/// Notes
///
/// This function does not initialize the returned array; to do that use
/// zeros_like or ones_like instead.
/// It may be marginally faster than
/// the functions that do set the array values.
///
///
/// The shape and data-type of prototype define these same attributes
/// of the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if prototype is Fortran
/// contiguous, ‘C’ otherwise.
/// ‘K’ means match the layout of prototype
/// as closely as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of uninitialized (arbitrary) data with the same
/// shape and type as prototype.
///
public static NDarray empty_like(NDarray prototype, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.empty_like(prototype, dtype:dtype, order:order, subok:subok);
///
/// Return a new array with the same shape and type as a given array.
///
/// Notes
///
/// This function does not initialize the returned array; to do that use
/// zeros_like or ones_like instead.
/// It may be marginally faster than
/// the functions that do set the array values.
///
///
/// The shape and data-type of prototype define these same attributes
/// of the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if prototype is Fortran
/// contiguous, ‘C’ otherwise.
/// ‘K’ means match the layout of prototype
/// as closely as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of uninitialized (arbitrary) data with the same
/// shape and type as prototype.
///
public static NDarray empty_like(T[] prototype, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.empty_like(prototype, dtype:dtype, order:order, subok:subok);
///
/// Return a new array with the same shape and type as a given array.
///
/// Notes
///
/// This function does not initialize the returned array; to do that use
/// zeros_like or ones_like instead.
/// It may be marginally faster than
/// the functions that do set the array values.
///
///
/// The shape and data-type of prototype define these same attributes
/// of the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if prototype is Fortran
/// contiguous, ‘C’ otherwise.
/// ‘K’ means match the layout of prototype
/// as closely as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of uninitialized (arbitrary) data with the same
/// shape and type as prototype.
///
public static NDarray empty_like(T[,] prototype, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.empty_like(prototype, dtype:dtype, order:order, subok:subok);
///
/// Return a 2-D array with ones on the diagonal and zeros elsewhere.
///
///
/// Number of rows in the output.
///
///
/// Number of columns in the output.
/// If None, defaults to N.
///
///
/// 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.
///
///
/// Data-type of the returned array.
///
///
/// Whether the output should be stored in row-major (C-style) or
/// column-major (Fortran-style) order in memory.
///
///
/// An array where all elements are equal to zero, except for the k-th
/// diagonal, whose values are equal to one.
///
public static NDarray eye(int N, int? M = null, int? k = 0, Dtype dtype = null, string order = null)
=> NumPy.Instance.eye(N, M:M, k:k, dtype:dtype, order:order);
///
/// Return the identity array.
///
/// The identity array is a square array with ones on
/// the main diagonal.
///
///
/// Number of rows (and columns) in n x n output.
///
///
/// Data-type of the output.
/// Defaults to float.
///
///
/// n x n array with its main diagonal set to one,
/// and all other elements 0.
///
public static NDarray identity(int n, Dtype dtype = null)
=> NumPy.Instance.identity(n, dtype:dtype);
///
/// Return a new array of given shape and type, filled with ones.
///
///
/// Shape of the new array, e.g., (2, 3) or 2.
///
///
/// The desired data-type for the array, e.g., numpy.int8. Default is
/// numpy.float64.
///
///
/// Whether to store multi-dimensional data in row-major
/// (C-style) or column-major (Fortran-style) order in
/// memory.
///
///
/// Array of ones with the given shape, dtype, and order.
///
public static NDarray ones(Shape shape, Dtype dtype = null, string order = null)
=> NumPy.Instance.ones(shape, dtype:dtype, order:order);
///
/// Return an array of ones with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of ones with the same shape and type as a.
///
public static NDarray ones_like(NDarray a, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.ones_like(a, dtype:dtype, order:order, subok:subok);
///
/// Return an array of ones with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of ones with the same shape and type as a.
///
public static NDarray ones_like(T[] a, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.ones_like(a, dtype:dtype, order:order, subok:subok);
///
/// Return an array of ones with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of ones with the same shape and type as a.
///
public static NDarray ones_like(T[,] a, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.ones_like(a, dtype:dtype, order:order, subok:subok);
///
/// Return a new array of given shape and type, filled with zeros.
///
///
/// Shape of the new array, e.g., (2, 3) or 2.
///
///
/// The desired data-type for the array, e.g., numpy.int8. Default is
/// numpy.float64.
///
///
/// Whether to store multi-dimensional data in row-major
/// (C-style) or column-major (Fortran-style) order in
/// memory.
///
///
/// Array of zeros with the given shape, dtype, and order.
///
public static NDarray zeros(Shape shape, Dtype dtype = null, string order = null)
=> NumPy.Instance.zeros(shape, dtype:dtype, order:order);
///
/// Return an array of zeros with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of zeros with the same shape and type as a.
///
public static NDarray zeros_like(NDarray a, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.zeros_like(a, dtype:dtype, order:order, subok:subok);
///
/// Return an array of zeros with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of zeros with the same shape and type as a.
///
public static NDarray zeros_like(T[] a, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.zeros_like(a, dtype:dtype, order:order, subok:subok);
///
/// Return an array of zeros with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of zeros with the same shape and type as a.
///
public static NDarray zeros_like(T[,] a, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.zeros_like(a, dtype:dtype, order:order, subok:subok);
///
/// Return a new array of given shape and type, filled with fill_value.
///
///
/// Shape of the new array, e.g., (2, 3) or 2.
///
///
/// Fill value.
///
///
/// Whether to store multidimensional data in C- or Fortran-contiguous
/// (row- or column-wise) order in memory.
///
///
/// Array of fill_value with the given shape, dtype, and order.
///
public static NDarray full(Shape shape, ValueType fill_value, Dtype dtype = null, string order = null)
=> NumPy.Instance.full(shape, fill_value, dtype:dtype, order:order);
///
/// Return a full array with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Fill value.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of fill_value with the same shape and type as a.
///
public static NDarray full_like(NDarray a, ValueType fill_value, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.full_like(a, fill_value, dtype:dtype, order:order, subok:subok);
///
/// Return a full array with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Fill value.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of fill_value with the same shape and type as a.
///
public static NDarray full_like(T[] a, ValueType fill_value, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.full_like(a, fill_value, dtype:dtype, order:order, subok:subok);
///
/// Return a full array with the same shape and type as a given array.
///
///
/// The shape and data-type of a define these same attributes of
/// the returned array.
///
///
/// Fill value.
///
///
/// Overrides the data type of the result.
///
///
/// Overrides the memory layout of the result.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
///
///
/// If True, then the newly created array will use the sub-class
/// type of ‘a’, otherwise it will be a base-class array.
/// Defaults
/// to True.
///
///
/// Array of fill_value with the same shape and type as a.
///
public static NDarray full_like(T[,] a, ValueType fill_value, Dtype dtype = null, string order = null, bool? subok = true)
=> NumPy.Instance.full_like(a, fill_value, dtype:dtype, order:order, subok:subok);
///
/// Create an array.
///
/// Notes
///
/// When order is ‘A’ and object is an array in neither ‘C’ nor ‘F’ order,
/// and a copy is forced by a change in dtype, then the order of the result is
/// not necessarily ‘C’ as expected.
/// This is likely a bug.
///
///
/// An array, any object exposing the array interface, an object whose
/// __array__ method returns an array, or any (nested) sequence.
///
///
/// The desired data-type for the array.
/// If not given, then the type will
/// be determined as the minimum type required to hold the objects in the
/// sequence.
/// This argument can only be used to ‘upcast’ the array.
/// For
/// downcasting, use the .astype(t) method.
///
///
/// If true (default), then the object is copied.
/// Otherwise, a copy will
/// only be made if __array__ returns a copy, if obj is a nested sequence,
/// or if a copy is needed to satisfy any of the other requirements
/// (dtype, order, etc.).
///
///
/// Specify the memory layout of the array.
/// If object is not an array, the
/// newly created array will be in C order (row major) unless ‘F’ is
/// specified, in which case it will be in Fortran order (column major).
///
/// If object is an array the following holds.
///
/// When copy=False and a copy is made for other reasons, the result is
/// the same as if copy=True, with some exceptions for A, see the
/// Notes section.
/// The default order is ‘K’.
///
///
/// If True, then sub-classes will be passed-through, otherwise
/// the returned array will be forced to be a base-class array (default).
///
///
/// Specifies the minimum number of dimensions that the resulting
/// array should have.
/// Ones will be pre-pended to the shape as
/// needed to meet this requirement.
///
///
/// An array object satisfying the specified requirements.
///
public static NDarray array(NDarray @object, Dtype dtype = null, bool? copy = true, string order = null, bool? subok = false, int? ndmin = 0)
=> NumPy.Instance.array(@object, dtype:dtype, copy:copy, order:order, subok:subok, ndmin:ndmin);
///
/// Create an array.
///
/// Notes
///
/// When order is ‘A’ and object is an array in neither ‘C’ nor ‘F’ order,
/// and a copy is forced by a change in dtype, then the order of the result is
/// not necessarily ‘C’ as expected.
/// This is likely a bug.
///
///
/// An array, any object exposing the array interface, an object whose
/// __array__ method returns an array, or any (nested) sequence.
///
///
/// The desired data-type for the array.
/// If not given, then the type will
/// be determined as the minimum type required to hold the objects in the
/// sequence.
/// This argument can only be used to ‘upcast’ the array.
/// For
/// downcasting, use the .astype(t) method.
///
///
/// If true (default), then the object is copied.
/// Otherwise, a copy will
/// only be made if __array__ returns a copy, if obj is a nested sequence,
/// or if a copy is needed to satisfy any of the other requirements
/// (dtype, order, etc.).
///
///
/// Specify the memory layout of the array.
/// If object is not an array, the
/// newly created array will be in C order (row major) unless ‘F’ is
/// specified, in which case it will be in Fortran order (column major).
///
/// If object is an array the following holds.
///
/// When copy=False and a copy is made for other reasons, the result is
/// the same as if copy=True, with some exceptions for A, see the
/// Notes section.
/// The default order is ‘K’.
///
///
/// If True, then sub-classes will be passed-through, otherwise
/// the returned array will be forced to be a base-class array (default).
///
///
/// Specifies the minimum number of dimensions that the resulting
/// array should have.
/// Ones will be pre-pended to the shape as
/// needed to meet this requirement.
///
///
/// An array object satisfying the specified requirements.
///
public static NDarray array(T[] @object, Dtype dtype = null, bool? copy = true, string order = null, bool? subok = false, int? ndmin = 0)
=> NumPy.Instance.array(@object, dtype:dtype, copy:copy, order:order, subok:subok, ndmin:ndmin);
///
/// Create an array.
///
/// Notes
///
/// When order is ‘A’ and object is an array in neither ‘C’ nor ‘F’ order,
/// and a copy is forced by a change in dtype, then the order of the result is
/// not necessarily ‘C’ as expected.
/// This is likely a bug.
///
///
/// An array, any object exposing the array interface, an object whose
/// __array__ method returns an array, or any (nested) sequence.
///
///
/// The desired data-type for the array.
/// If not given, then the type will
/// be determined as the minimum type required to hold the objects in the
/// sequence.
/// This argument can only be used to ‘upcast’ the array.
/// For
/// downcasting, use the .astype(t) method.
///
///
/// If true (default), then the object is copied.
/// Otherwise, a copy will
/// only be made if __array__ returns a copy, if obj is a nested sequence,
/// or if a copy is needed to satisfy any of the other requirements
/// (dtype, order, etc.).
///
///
/// Specify the memory layout of the array.
/// If object is not an array, the
/// newly created array will be in C order (row major) unless ‘F’ is
/// specified, in which case it will be in Fortran order (column major).
///
/// If object is an array the following holds.
///
/// When copy=False and a copy is made for other reasons, the result is
/// the same as if copy=True, with some exceptions for A, see the
/// Notes section.
/// The default order is ‘K’.
///
///
/// If True, then sub-classes will be passed-through, otherwise
/// the returned array will be forced to be a base-class array (default).
///
///
/// Specifies the minimum number of dimensions that the resulting
/// array should have.
/// Ones will be pre-pended to the shape as
/// needed to meet this requirement.
///
///
/// An array object satisfying the specified requirements.
///
public static NDarray array(T[,] @object, Dtype dtype = null, bool? copy = true, string order = null, bool? subok = false, int? ndmin = 0)
=> NumPy.Instance.array(@object, dtype:dtype, copy:copy, order:order, subok:subok, ndmin:ndmin);
///
/// Convert the input to an array.
///
///
/// Input data, in any form that can be converted to an array.
/// This
/// includes lists, lists of tuples, tuples, tuples of tuples, tuples
/// of lists and ndarrays.
///
///
/// By default, the data-type is inferred from the input data.
///
///
/// Whether to use row-major (C-style) or
/// column-major (Fortran-style) memory representation.
///
/// Defaults to ‘C’.
///
///
/// Array interpretation of a.
/// No copy is performed if the input
/// is already an ndarray with matching dtype and order.
/// If a is a
/// subclass of ndarray, a base class ndarray is returned.
///
public static NDarray asarray(NDarray a, Dtype dtype = null, string order = null)
=> NumPy.Instance.asarray(a, dtype:dtype, order:order);
///
/// Convert the input to an array.
///
///
/// Input data, in any form that can be converted to an array.
/// This
/// includes lists, lists of tuples, tuples, tuples of tuples, tuples
/// of lists and ndarrays.
///
///
/// By default, the data-type is inferred from the input data.
///
///
/// Whether to use row-major (C-style) or
/// column-major (Fortran-style) memory representation.
///
/// Defaults to ‘C’.
///
///
/// Array interpretation of a.
/// No copy is performed if the input
/// is already an ndarray with matching dtype and order.
/// If a is a
/// subclass of ndarray, a base class ndarray is returned.
///
public static NDarray asarray(T[] a, Dtype dtype = null, string order = null)
=> NumPy.Instance.asarray(a, dtype:dtype, order:order);
///
/// Convert the input to an array.
///
///
/// Input data, in any form that can be converted to an array.
/// This
/// includes lists, lists of tuples, tuples, tuples of tuples, tuples
/// of lists and ndarrays.
///
///
/// By default, the data-type is inferred from the input data.
///
///
/// Whether to use row-major (C-style) or
/// column-major (Fortran-style) memory representation.
///
/// Defaults to ‘C’.
///
///
/// Array interpretation of a.
/// No copy is performed if the input
/// is already an ndarray with matching dtype and order.
/// If a is a
/// subclass of ndarray, a base class ndarray is returned.
///
public static NDarray asarray(T[,] a, Dtype dtype = null, string order = null)
=> NumPy.Instance.asarray(a, dtype:dtype, order:order);
///
/// Convert the input to an ndarray, but pass ndarray subclasses through.
///
///
/// Input data, in any form that can be converted to an array.
/// This
/// includes scalars, lists, lists of tuples, tuples, tuples of tuples,
/// tuples of lists, and ndarrays.
///
///
/// By default, the data-type is inferred from the input data.
///
///
/// Whether to use row-major (C-style) or column-major
/// (Fortran-style) memory representation.
/// Defaults to ‘C’.
///
///
/// Array interpretation of a.
/// If a is an ndarray or a subclass
/// of ndarray, it is returned as-is and no copy is performed.
///
public static NDarray asanyarray(NDarray a, Dtype dtype = null, string order = null)
=> NumPy.Instance.asanyarray(a, dtype:dtype, order:order);
///
/// Convert the input to an ndarray, but pass ndarray subclasses through.
///
///
/// Input data, in any form that can be converted to an array.
/// This
/// includes scalars, lists, lists of tuples, tuples, tuples of tuples,
/// tuples of lists, and ndarrays.
///
///
/// By default, the data-type is inferred from the input data.
///
///
/// Whether to use row-major (C-style) or column-major
/// (Fortran-style) memory representation.
/// Defaults to ‘C’.
///
///
/// Array interpretation of a.
/// If a is an ndarray or a subclass
/// of ndarray, it is returned as-is and no copy is performed.
///
public static NDarray asanyarray(T[] a, Dtype dtype = null, string order = null)
=> NumPy.Instance.asanyarray(a, dtype:dtype, order:order);
///
/// Convert the input to an ndarray, but pass ndarray subclasses through.
///
///
/// Input data, in any form that can be converted to an array.
/// This
/// includes scalars, lists, lists of tuples, tuples, tuples of tuples,
/// tuples of lists, and ndarrays.
///
///
/// By default, the data-type is inferred from the input data.
///
///
/// Whether to use row-major (C-style) or column-major
/// (Fortran-style) memory representation.
/// Defaults to ‘C’.
///
///
/// Array interpretation of a.
/// If a is an ndarray or a subclass
/// of ndarray, it is returned as-is and no copy is performed.
///
public static NDarray asanyarray(T[,] a, Dtype dtype = null, string order = null)
=> NumPy.Instance.asanyarray(a, dtype:dtype, order:order);
///
/// Return a contiguous array (ndim >= 1) in memory (C order).
///
///
/// Input array.
///
///
/// Data-type of returned array.
///
///
/// Contiguous array of same shape and content as a, with type dtype
/// if specified.
///
public static NDarray ascontiguousarray(NDarray a, Dtype dtype = null)
=> NumPy.Instance.ascontiguousarray(a, dtype:dtype);
///
/// Return a contiguous array (ndim >= 1) in memory (C order).
///
///
/// Input array.
///
///
/// Data-type of returned array.
///
///
/// Contiguous array of same shape and content as a, with type dtype
/// if specified.
///
public static NDarray ascontiguousarray(T[] a, Dtype dtype = null)
=> NumPy.Instance.ascontiguousarray(a, dtype:dtype);
///
/// Return a contiguous array (ndim >= 1) in memory (C order).
///
///
/// Input array.
///
///
/// Data-type of returned array.
///
///
/// Contiguous array of same shape and content as a, with type dtype
/// if specified.
///
public static NDarray ascontiguousarray(T[,] a, Dtype dtype = null)
=> NumPy.Instance.ascontiguousarray(a, dtype:dtype);
///
/// Interpret the input as a matrix.
///
/// Unlike matrix, asmatrix does not make a copy if the input is already
/// a matrix or an ndarray.
/// Equivalent to matrix(data, copy=False).
///
///
/// Input data.
///
///
/// Data-type of the output matrix.
///
///
/// data interpreted as a matrix.
///
public static Matrix asmatrix(NDarray data, Dtype dtype)
=> NumPy.Instance.asmatrix(data, dtype);
///
/// Interpret the input as a matrix.
///
/// Unlike matrix, asmatrix does not make a copy if the input is already
/// a matrix or an ndarray.
/// Equivalent to matrix(data, copy=False).
///
///
/// Input data.
///
///
/// Data-type of the output matrix.
///
///
/// data interpreted as a matrix.
///
public static Matrix asmatrix(T[] data, Dtype dtype)
=> NumPy.Instance.asmatrix(data, dtype);
///
/// Interpret the input as a matrix.
///
/// Unlike matrix, asmatrix does not make a copy if the input is already
/// a matrix or an ndarray.
/// Equivalent to matrix(data, copy=False).
///
///
/// Input data.
///
///
/// Data-type of the output matrix.
///
///
/// data interpreted as a matrix.
///
public static Matrix asmatrix(T[,] data, Dtype dtype)
=> NumPy.Instance.asmatrix(data, dtype);
///
/// Return an array copy of the given object.
///
/// Notes
///
/// This is equivalent to:
///
///
/// Input data.
///
///
/// Controls the memory layout of the copy.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
/// (Note that this function and ndarray.copy are very
/// similar, but have different default values for their order=
/// arguments.)
///
///
/// Array interpretation of a.
///
public static NDarray copy(NDarray a, string order = null)
=> NumPy.Instance.copy(a, order:order);
///
/// Return an array copy of the given object.
///
/// Notes
///
/// This is equivalent to:
///
///
/// Input data.
///
///
/// Controls the memory layout of the copy.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
/// (Note that this function and ndarray.copy are very
/// similar, but have different default values for their order=
/// arguments.)
///
///
/// Array interpretation of a.
///
public static NDarray copy(T[] a, string order = null)
=> NumPy.Instance.copy(a, order:order);
///
/// Return an array copy of the given object.
///
/// Notes
///
/// This is equivalent to:
///
///
/// Input data.
///
///
/// Controls the memory layout of the copy.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
/// (Note that this function and ndarray.copy are very
/// similar, but have different default values for their order=
/// arguments.)
///
///
/// Array interpretation of a.
///
public static NDarray copy(T[,] a, string order = null)
=> NumPy.Instance.copy(a, order:order);
/*
///
/// Interpret a buffer as a 1-dimensional array.
///
/// Notes
///
/// If the buffer has data that is not in machine byte-order, this should
/// be specified as part of the data-type, e.g.:
///
/// The data of the resulting array will not be byteswapped, but will be
/// interpreted correctly.
///
///
/// An object that exposes the buffer interface.
///
///
/// Data-type of the returned array; default: float.
///
///
/// Number of items to read.
/// -1 means all data in the buffer.
///
///
/// Start reading the buffer from this offset (in bytes); default: 0.
///
public static void frombuffer(buffer_like buffer, Dtype dtype = null, int? count = -1, int? offset = 0)
=> NumPy.Instance.frombuffer(buffer, dtype:dtype, count:count, offset:offset);
*/
///
/// Construct an array from data in a text or binary file.
///
/// A highly efficient way of reading binary data with a known data-type,
/// as well as parsing simply formatted text files.
/// Data written using the
/// tofile method can be read using this function.
///
/// Notes
///
/// Do not rely on the combination of tofile and fromfile for
/// data storage, as the binary files generated are are not platform
/// independent.
/// In particular, no byte-order or data-type information is
/// saved.
/// Data can be stored in the platform independent .npy format
/// using save and load instead.
///
///
/// Open file object or filename.
///
///
/// Data type of the returned array.
///
/// For binary files, it is used to determine the size and byte-order
/// of the items in the file.
///
///
/// Number of items to read.
/// -1 means all items (i.e., the complete
/// file).
///
///
/// Separator between items if file is a text file.
///
/// Empty (“”) separator means the file should be treated as binary.
///
/// Spaces (” “) in the separator match zero or more whitespace characters.
///
/// A separator consisting only of spaces must match at least one
/// whitespace.
///
public static void fromfile(string file, Dtype dtype = null, int count = -1, string sep = "")
=> NumPy.Instance.fromfile(file, dtype:dtype, count:count, sep:sep);
///
/// Construct an array by executing a function over each coordinate.
///
/// The resulting array therefore has a value fn(x, y, z) at
/// coordinate (x, y, z).
///
/// Notes
///
/// Keywords other than dtype are passed to function.
///
///
/// The function is called with N parameters, where N is the rank of
/// shape.
/// Each parameter represents the coordinates of the array
/// varying along a specific axis.
/// For example, if shape
/// were (2, 2), then the parameters would be
/// array([[0, 0], [1, 1]]) and array([[0, 1], [0, 1]])
///
///
/// Shape of the output array, which also determines the shape of
/// the coordinate arrays passed to function.
///
///
/// Data-type of the coordinate arrays passed to function.
///
/// By default, dtype is float.
///
///
/// The result of the call to function is passed back directly.
///
/// Therefore the shape of fromfunction is completely determined by
/// function.
/// If function returns a scalar value, the shape of
/// fromfunction would not match the shape parameter.
///
public static object fromfunction(Delegate function, Shape shape, Dtype dtype = null)
=> NumPy.Instance.fromfunction(function, shape, dtype:dtype);
///
/// Create a new 1-dimensional array from an iterable object.
///
/// Notes
///
/// Specify count to improve performance.
/// It allows fromiter to
/// pre-allocate the output array, instead of resizing it on demand.
///
///
/// An iterable object providing data for the array.
///
///
/// The data-type of the returned array.
///
///
/// The number of items to read from iterable.
/// The default is -1,
/// which means all data is read.
///
///
/// The output array.
///
public static NDarray fromiter(IEnumerable iterable, Dtype dtype, int? count = -1)
=> NumPy.Instance.fromiter(iterable, dtype, count:count);
///
/// A new 1-D array initialized from text data in a string.
///
///
/// A string containing the data.
///
///
/// The data type of the array; default: float.
/// For binary input data,
/// the data must be in exactly this format.
///
///
/// Read this number of dtype elements from the data.
/// If this is
/// negative (the default), the count will be determined from the
/// length of the data.
///
///
/// The string separating numbers in the data; extra whitespace between
/// elements is also ignored.
///
///
/// The constructed array.
///
public static NDarray fromstring(string @string, Dtype dtype = null, int? count = -1, string sep = "")
=> NumPy.Instance.fromstring(@string, dtype:dtype, count:count, sep:sep);
///
/// Load data from a text file.
///
/// Each row in the text file must have the same number of values.
///
/// Notes
///
/// This function aims to be a fast reader for simply formatted files.
/// The
/// genfromtxt function provides more sophisticated handling of, e.g.,
/// lines with missing values.
///
/// The strings produced by the Python float.hex method can be used as
/// input for floats.
///
///
/// File, filename, or generator to read.
/// If the filename extension is
/// .gz or .bz2, the file is first decompressed.
/// Note that
/// generators should return byte strings for Python 3k.
///
///
/// Data-type of the resulting array; default: float.
/// If this is a
/// structured data-type, the resulting array will be 1-dimensional, and
/// each row will be interpreted as an element of the array.
/// In this
/// case, the number of columns used must match the number of fields in
/// the data-type.
///
///
/// The characters or list of characters used to indicate the start of a
/// comment.
/// None implies no comments.
/// For backwards compatibility, byte
/// strings will be decoded as ‘latin1’. The default is ‘#’.
///
///
/// The string used to separate values.
/// For backwards compatibility, byte
/// strings will be decoded as ‘latin1’. The default is whitespace.
///
///
/// A dictionary mapping column number to a function that will parse the
/// column string into the desired value.
/// E.g., if column 0 is a date
/// string: converters = {0: datestr2num}. Converters can also be
/// used to provide a default value for missing data (but see also
/// genfromtxt): converters = {3: lambda s: float(s.strip() or 0)}.
/// Default: None.
///
///
/// Skip the first skiprows lines; default: 0.
///
///
/// Which columns to read, with 0 being the first.
/// For example,
/// usecols = (1,4,5) will extract the 2nd, 5th and 6th columns.
///
/// The default, None, results in all columns being read.
///
///
/// If True, the returned array is transposed, so that arguments may be
/// unpacked using x, y, z = loadtxt(...).
/// When used with a structured
/// data-type, arrays are returned for each field.
/// Default is False.
///
///
/// The returned array will have at least ndmin dimensions.
///
/// Otherwise mono-dimensional axes will be squeezed.
///
/// Legal values: 0 (default), 1 or 2.
///
///
/// Encoding used to decode the inputfile.
/// Does not apply to input streams.
///
/// The special value ‘bytes’ enables backward compatibility workarounds
/// that ensures you receive byte arrays as results if possible and passes
/// ‘latin1’ encoded strings to converters.
/// Override this value to receive
/// unicode arrays and pass strings as input to converters.
/// If set to None
/// the system default is used.
/// The default value is ‘bytes’.
///
///
/// Read max_rows lines of content after skiprows lines.
/// The default
/// is to read all the lines.
///
///
/// Data read from the text file.
///
public static NDarray loadtxt(string fname, Dtype dtype = null, string[] comments = null, string delimiter = null, Hashtable converters = null, int? skiprows = 0, int[] usecols = null, bool? unpack = false, int? ndmin = 0, string encoding = "bytes", int? max_rows = null)
=> NumPy.Instance.loadtxt(fname, dtype:dtype, comments:comments, delimiter:delimiter, converters:converters, skiprows:skiprows, usecols:usecols, unpack:unpack, ndmin:ndmin, encoding:encoding, max_rows:max_rows);
public static partial class core {
public static partial class defchararray {
///
/// Create a chararray.
///
/// Versus a regular NumPy array of type str or unicode, this
/// class adds the following functionality:
///
///
/// itemsize is the number of characters per scalar in the
/// resulting array.
/// If itemsize is None, and obj is an
/// object array or a Python list, the itemsize will be
/// automatically determined.
/// If itemsize is provided and obj
/// is of type str or unicode, then the obj string will be
/// chunked into itemsize pieces.
///
///
/// If true (default), then the object is copied.
/// Otherwise, a copy
/// will only be made if __array__ returns a copy, if obj is a
/// nested sequence, or if a copy is needed to satisfy any of the other
/// requirements (itemsize, unicode, order, etc.).
///
///
/// When true, the resulting chararray can contain Unicode
/// characters, when false only 8-bit characters.
/// If unicode is
/// None and obj is one of the following:
///
/// then the unicode setting of the output array will be
/// automatically determined.
///
///
/// Specify the order of the array.
/// If order is ‘C’ (default), then the
/// array will be in C-contiguous order (last-index varies the
/// fastest).
/// If order is ‘F’, then the returned array
/// will be in Fortran-contiguous order (first-index varies the
/// fastest).
/// If order is ‘A’, then the returned array may
/// be in any order (either C-, Fortran-contiguous, or even
/// discontiguous).
///
public static void array(string[] obj, int? itemsize = null, bool? copy = true, bool? unicode = null, string order = null)
=> NumPy.Instance.core_defchararray_array(obj, itemsize:itemsize, copy:copy, unicode:unicode, order:order);
}
}
///
/// Provides a convenient view on arrays of string and unicode values.
///
/// Versus a regular NumPy array of type str or unicode, this
/// class adds the following functionality:
///
/// chararrays should be created using numpy.char.array or
/// numpy.char.asarray, rather than this constructor directly.
///
/// This constructor creates the array, using buffer (with offset
/// and strides) if it is not None.
/// If buffer is None, then
/// constructs a new array with strides in “C order”, unless both
/// len(shape) >= 2 and order='Fortran', in which case strides
/// is in “Fortran order”.
///
///
/// Shape of the array.
///
///
/// Length of each array element, in number of characters.
/// Default is 1.
///
///
/// Are the array elements of type unicode (True) or string (False).
///
/// Default is False.
///
///
/// Memory address of the start of the array data.
/// Default is None,
/// in which case a new array is created.
///
///
/// Fixed stride displacement from the beginning of an axis?
/// Default is 0.
/// Needs to be >=0.
///
///
/// Strides for the array (see ndarray.strides for full description).
///
/// Default is None.
///
///
/// The order in which the array data is stored in memory: ‘C’ ->
/// “row major” order (the default), ‘F’ -> “column major”
/// (Fortran) order.
///
public static void chararray(Shape shape, int? itemsize = null, bool? unicode = null, int? buffer = null, int? offset = null, int[] strides = null, string order = null)
=> NumPy.Instance.chararray(shape, itemsize:itemsize, unicode:unicode, buffer:buffer, offset:offset, strides:strides, order:order);
public static partial class core {
public static partial class defchararray {
///
/// Convert the input to a chararray, copying the data only if
/// necessary.
///
/// Versus a regular NumPy array of type str or unicode, this
/// class adds the following functionality:
///
///
/// itemsize is the number of characters per scalar in the
/// resulting array.
/// If itemsize is None, and obj is an
/// object array or a Python list, the itemsize will be
/// automatically determined.
/// If itemsize is provided and obj
/// is of type str or unicode, then the obj string will be
/// chunked into itemsize pieces.
///
///
/// When true, the resulting chararray can contain Unicode
/// characters, when false only 8-bit characters.
/// If unicode is
/// None and obj is one of the following:
///
/// then the unicode setting of the output array will be
/// automatically determined.
///
///
/// Specify the order of the array.
/// If order is ‘C’ (default), then the
/// array will be in C-contiguous order (last-index varies the
/// fastest).
/// If order is ‘F’, then the returned array
/// will be in Fortran-contiguous order (first-index varies the
/// fastest).
///
public static void asarray(string[] obj, int? itemsize = null, bool? unicode = null, string order = null)
=> NumPy.Instance.core_defchararray_asarray(obj, itemsize:itemsize, unicode:unicode, order:order);
}
}
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// Start of interval.
/// The interval includes this value.
/// The default
/// start value is 0.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(byte start, byte stop, byte step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(start, stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(byte stop, byte step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// Start of interval.
/// The interval includes this value.
/// The default
/// start value is 0.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(short start, short stop, short step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(start, stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(short stop, short step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// Start of interval.
/// The interval includes this value.
/// The default
/// start value is 0.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(int start, int stop, int step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(start, stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(int stop, int step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// Start of interval.
/// The interval includes this value.
/// The default
/// start value is 0.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(long start, long stop, long step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(start, stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(long stop, long step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// Start of interval.
/// The interval includes this value.
/// The default
/// start value is 0.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(float start, float stop, float step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(start, stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(float stop, float step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// Start of interval.
/// The interval includes this value.
/// The default
/// start value is 0.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(double start, double stop, double step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(start, stop, step:step, dtype:dtype);
///
/// Return evenly spaced values within a given interval.
///
/// Values are generated within the half-open interval [start, stop)
/// (in other words, the interval including start but excluding stop).
///
/// For integer arguments the function is equivalent to the Python built-in
/// range function, but returns an ndarray rather than a list.
///
/// When using a non-integer step, such as 0.1, the results will often not
/// be consistent.
/// It is better to use numpy.linspace for these cases.
///
///
/// End of interval.
/// The interval does not include this value, except
/// in some cases where step is not an integer and floating point
/// round-off affects the length of out.
///
///
/// Spacing between values.
/// For any output out, this is the distance
/// between two adjacent values, out[i+1] - out[i].
/// The default
/// step size is 1.
/// If step is specified as a position argument,
/// start must also be given.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// Array of evenly spaced values.
///
/// For floating point arguments, the length of the result is
/// ceil((stop - start)/step).
/// Because of floating point overflow,
/// this rule may result in the last element of out being greater
/// than stop.
///
public static NDarray arange(double stop, double step = 1, Dtype dtype = null)
=> NumPy.Instance.arange(stop, step:step, dtype:dtype);
///
/// Return evenly spaced numbers over a specified interval.
///
/// Returns num evenly spaced samples, calculated over the
/// interval [start, stop].
///
/// The endpoint of the interval can optionally be excluded.
///
///
/// The starting value of the sequence.
///
///
/// The end value of the sequence, unless endpoint is set to False.
///
/// In that case, the sequence consists of all but the last of num + 1
/// evenly spaced samples, so that stop is excluded.
/// Note that the step
/// size changes when endpoint is False.
///
///
/// Number of samples to generate.
/// Default is 50. Must be non-negative.
///
///
/// If True, stop is the last sample.
/// Otherwise, it is not included.
///
/// Default is True.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// The axis in the result to store the samples.
/// Relevant only if start
/// or stop are array-like.
/// By default (0), the samples will be along a
/// new axis inserted at the beginning.
/// Use -1 to get an axis at the end.
///
///
/// A tuple of:
/// samples
/// There are num equally spaced samples in the closed interval
/// [start, stop] or the half-open interval [start, stop)
/// (depending on whether endpoint is True or False).
/// step
/// Only returned if retstep is True
///
/// Size of spacing between samples.
///
public static (NDarray, float) linspace(NDarray start, NDarray stop, int? num = 50, bool? endpoint = true, Dtype dtype = null, int? axis = 0)
=> NumPy.Instance.linspace(start, stop, num:num, endpoint:endpoint, dtype:dtype, axis:axis);
///
/// Return evenly spaced numbers over a specified interval.
///
/// Returns num evenly spaced samples, calculated over the
/// interval [start, stop].
///
/// The endpoint of the interval can optionally be excluded.
///
///
/// The starting value of the sequence.
///
///
/// The end value of the sequence, unless endpoint is set to False.
///
/// In that case, the sequence consists of all but the last of num + 1
/// evenly spaced samples, so that stop is excluded.
/// Note that the step
/// size changes when endpoint is False.
///
///
/// Number of samples to generate.
/// Default is 50. Must be non-negative.
///
///
/// If True, stop is the last sample.
/// Otherwise, it is not included.
///
/// Default is True.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// The axis in the result to store the samples.
/// Relevant only if start
/// or stop are array-like.
/// By default (0), the samples will be along a
/// new axis inserted at the beginning.
/// Use -1 to get an axis at the end.
///
///
/// There are num equally spaced samples in the closed interval
/// [start, stop] or the half-open interval [start, stop)
/// (depending on whether endpoint is True or False).
///
public static NDarray linspace(double start, double stop, int? num = 50, bool? endpoint = true, Dtype dtype = null, int? axis = 0)
=> NumPy.Instance.linspace(start, stop, num:num, endpoint:endpoint, dtype:dtype, axis:axis);
///
/// Return numbers spaced evenly on a log scale.
///
/// In linear space, the sequence starts at base ** start
/// (base to the power of start) and ends with base ** stop
/// (see endpoint below).
///
/// Notes
///
/// Logspace is equivalent to the code
///
///
/// base ** start is the starting value of the sequence.
///
///
/// base ** stop is the final value of the sequence, unless endpoint
/// is False.
/// In that case, num + 1 values are spaced over the
/// interval in log-space, of which all but the last (a sequence of
/// length num) are returned.
///
///
/// Number of samples to generate.
/// Default is 50.
///
///
/// If true, stop is the last sample.
/// Otherwise, it is not included.
///
/// Default is True.
///
///
/// The base of the log space.
/// The step size between the elements in
/// ln(samples) / ln(base) (or log_base(samples)) is uniform.
///
/// Default is 10.0.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// The axis in the result to store the samples.
/// Relevant only if start
/// or stop are array-like.
/// By default (0), the samples will be along a
/// new axis inserted at the beginning.
/// Use -1 to get an axis at the end.
///
///
/// num samples, equally spaced on a log scale.
///
public static NDarray logspace(NDarray start, NDarray stop, int? num = 50, bool? endpoint = true, float? @base = 10.0f, Dtype dtype = null, int? axis = 0)
=> NumPy.Instance.logspace(start, stop, num:num, endpoint:endpoint, @base:@base, dtype:dtype, axis:axis);
///
/// Return numbers spaced evenly on a log scale (a geometric progression).
///
/// This is similar to logspace, but with endpoints specified directly.
///
/// Each output sample is a constant multiple of the previous.
///
/// Notes
///
/// If the inputs or dtype are complex, the output will follow a logarithmic
/// spiral in the complex plane.
/// (There are an infinite number of spirals
/// passing through two points; the output will follow the shortest such path.)
///
///
/// The starting value of the sequence.
///
///
/// The final value of the sequence, unless endpoint is False.
///
/// In that case, num + 1 values are spaced over the
/// interval in log-space, of which all but the last (a sequence of
/// length num) are returned.
///
///
/// Number of samples to generate.
/// Default is 50.
///
///
/// If true, stop is the last sample.
/// Otherwise, it is not included.
///
/// Default is True.
///
///
/// The type of the output array.
/// If dtype is not given, infer the data
/// type from the other input arguments.
///
///
/// The axis in the result to store the samples.
/// Relevant only if start
/// or stop are array-like.
/// By default (0), the samples will be along a
/// new axis inserted at the beginning.
/// Use -1 to get an axis at the end.
///
///
/// num samples, equally spaced on a log scale.
///
public static NDarray geomspace(NDarray start, NDarray stop, int? num = 50, bool? endpoint = true, Dtype dtype = null, int? axis = 0)
=> NumPy.Instance.geomspace(start, stop, num:num, endpoint:endpoint, dtype:dtype, axis:axis);
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(NDarray x2, NDarray x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(T[] x2, array_like x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(T[,] x2, array_like x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(NDarray x2, T[] x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(NDarray x2, T[,] x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(T[] x2, T[] x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(T[] x2, T[,] x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(T[,] x2, T[] x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
/*
///
/// Return coordinate matrices from coordinate vectors.
///
/// Make N-D coordinate arrays for vectorized evaluations of
/// N-D scalar/vector fields over N-D grids, given
/// one-dimensional coordinate arrays x1, x2,…, xn.
///
/// Notes
///
/// This function supports both indexing conventions through the indexing
/// keyword argument.
/// Giving the string ‘ij’ returns a meshgrid with
/// matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing.
///
/// In the 2-D case with inputs of length M and N, the outputs are of shape
/// (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing.
/// In the 3-D case
/// with inputs of length M, N and P, outputs are of shape (N, M, P) for
/// ‘xy’ indexing and (M, N, P) for ‘ij’ indexing.
/// The difference is
/// illustrated by the following code snippet:
///
/// In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// 1-D arrays representing the coordinates of a grid.
///
///
/// Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.
///
/// See Notes for more details.
///
///
/// If True a sparse grid is returned in order to conserve memory.
///
/// Default is False.
///
///
/// If False, a view into the original arrays are returned in order to
/// conserve memory.
/// Default is True.
/// Please note that
/// sparse=False, copy=False will likely return non-contiguous
/// arrays.
/// Furthermore, more than one element of a broadcast array
/// may refer to a single memory location.
/// If you need to write to the
/// arrays, make copies first.
///
///
/// For vectors x1, x2,…, ‘xn’ with lengths Ni=len(xi) ,
/// return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’
/// or (N2, N1, N3,...Nn) shaped arrays if indexing=’xy’
/// with the elements of xi repeated to fill the matrix along
/// the first dimension for x1, the second for x2 and so on.
///
public static NDarray meshgrid(T[,] x2, T[,] x1, string indexing = null, bool? sparse = null, bool? copy = null)
=> NumPy.Instance.meshgrid(x2, x1, indexing:indexing, sparse:sparse, copy:copy);
*/
///
/// nd_grid instance which returns a dense multi-dimensional “meshgrid”.
///
/// An instance of numpy.lib.index_tricks.nd_grid which returns an dense
/// (or fleshed out) mesh-grid when indexed, so that each returned argument
/// has the same shape.
/// The dimensions and number of the output arrays are
/// equal to the number of indexing dimensions.
/// If the step length is not a
/// complex number, then the stop is not inclusive.
///
/// However, if the step length is a complex number (e.g.
/// 5j), then
/// the integer part of its magnitude is interpreted as specifying the
/// number of points to create between the start and stop values, where
/// the stop value is inclusive.
///
public static void mgrid()
=> NumPy.Instance.mgrid();
/*
///
/// nd_grid instance which returns an open multi-dimensional “meshgrid”.
///
/// An instance of numpy.lib.index_tricks.nd_grid which returns an open
/// (i.e.
/// not fleshed out) mesh-grid when indexed, so that only one dimension
/// of each returned array is greater than 1.
/// The dimension and number of the
/// output arrays are equal to the number of indexing dimensions.
/// If the step
/// length is not a complex number, then the stop is not inclusive.
///
/// However, if the step length is a complex number (e.g.
/// 5j), then
/// the integer part of its magnitude is interpreted as specifying the
/// number of points to create between the start and stop values, where
/// the stop value is inclusive.
///
public static void ogrid(math mesh-grid `ndarrays` with only one dimension)
=> NumPy.Instance.ogrid(mesh-grid `ndarrays` with only one dimension);
*/
///
/// Extract a diagonal or construct a diagonal array.
///
/// See the more detailed documentation for numpy.diagonal if you use this
/// function to extract a diagonal and wish to write to the resulting array;
/// whether it returns a copy or a view depends on what version of numpy you
/// are using.
///
///
/// If v is a 2-D array, return a copy of its k-th diagonal.
///
/// If v is a 1-D array, return a 2-D array with v on the k-th
/// diagonal.
///
///
/// Diagonal in question.
/// The default is 0.
/// Use k>0 for diagonals
/// above the main diagonal, and k<0 for diagonals below the main
/// diagonal.
///
///
/// The extracted diagonal or constructed diagonal array.
///
public static NDarray diag(NDarray v, int? k = 0)
=> NumPy.Instance.diag(v, k:k);
///
/// Extract a diagonal or construct a diagonal array.
///
/// See the more detailed documentation for numpy.diagonal if you use this
/// function to extract a diagonal and wish to write to the resulting array;
/// whether it returns a copy or a view depends on what version of numpy you
/// are using.
///
///
/// If v is a 2-D array, return a copy of its k-th diagonal.
///
/// If v is a 1-D array, return a 2-D array with v on the k-th
/// diagonal.
///
///
/// Diagonal in question.
/// The default is 0.
/// Use k>0 for diagonals
/// above the main diagonal, and k<0 for diagonals below the main
/// diagonal.
///
///
/// The extracted diagonal or constructed diagonal array.
///
public static NDarray diag(T[] v, int? k = 0)
=> NumPy.Instance.diag(v, k:k);
///
/// Extract a diagonal or construct a diagonal array.
///
/// See the more detailed documentation for numpy.diagonal if you use this
/// function to extract a diagonal and wish to write to the resulting array;
/// whether it returns a copy or a view depends on what version of numpy you
/// are using.
///
///
/// If v is a 2-D array, return a copy of its k-th diagonal.
///
/// If v is a 1-D array, return a 2-D array with v on the k-th
/// diagonal.
///
///
/// Diagonal in question.
/// The default is 0.
/// Use k>0 for diagonals
/// above the main diagonal, and k<0 for diagonals below the main
/// diagonal.
///
///
/// The extracted diagonal or constructed diagonal array.
///
public static NDarray diag(T[,] v, int? k = 0)
=> NumPy.Instance.diag(v, k:k);
///
/// Create a two-dimensional array with the flattened input as a diagonal.
///
///
/// Input data, which is flattened and set as the k-th
/// diagonal of the output.
///
///
/// Diagonal to set; 0, the default, corresponds to the “main” diagonal,
/// a positive (negative) k giving the number of the diagonal above
/// (below) the main.
///
///
/// The 2-D output array.
///
public static NDarray diagflat(NDarray v, int? k = 0)
=> NumPy.Instance.diagflat(v, k:k);
///
/// Create a two-dimensional array with the flattened input as a diagonal.
///
///
/// Input data, which is flattened and set as the k-th
/// diagonal of the output.
///
///
/// Diagonal to set; 0, the default, corresponds to the “main” diagonal,
/// a positive (negative) k giving the number of the diagonal above
/// (below) the main.
///
///
/// The 2-D output array.
///
public static NDarray diagflat(T[] v, int? k = 0)
=> NumPy.Instance.diagflat(v, k:k);
///
/// Create a two-dimensional array with the flattened input as a diagonal.
///
///
/// Input data, which is flattened and set as the k-th
/// diagonal of the output.
///
///
/// Diagonal to set; 0, the default, corresponds to the “main” diagonal,
/// a positive (negative) k giving the number of the diagonal above
/// (below) the main.
///
///
/// The 2-D output array.
///
public static NDarray diagflat(T[,] v, int? k = 0)
=> NumPy.Instance.diagflat(v, k:k);
///
/// An array with ones at and below the given diagonal and zeros elsewhere.
///
///
/// Number of rows in the array.
///
///
/// Number of columns in the array.
///
/// By default, M is taken equal to N.
///
///
/// The sub-diagonal at and below which the array is filled.
///
/// k = 0 is the main diagonal, while k < 0 is below it,
/// and k > 0 is above.
/// The default is 0.
///
///
/// Data type of the returned array.
/// The default is float.
///
///
/// Array with its lower triangle filled with ones and zero elsewhere;
/// in other words T[i,j] == 1 for i <= j + k, 0 otherwise.
///
public static NDarray tri(int N, int? M = null, int? k = 0, Dtype dtype = null)
=> NumPy.Instance.tri(N, M:M, k:k, dtype:dtype);
///
/// Lower triangle of an array.
///
/// Return a copy of an array with elements above the k-th diagonal zeroed.
///
///
/// Input array.
///
///
/// Diagonal above which to zero elements.
/// k = 0 (the default) is the
/// main diagonal, k < 0 is below it and k > 0 is above.
///
///
/// Lower triangle of m, of same shape and data-type as m.
///
public static NDarray tril(NDarray m, int? k = 0)
=> NumPy.Instance.tril(m, k:k);
///
/// Lower triangle of an array.
///
/// Return a copy of an array with elements above the k-th diagonal zeroed.
///
///
/// Input array.
///
///
/// Diagonal above which to zero elements.
/// k = 0 (the default) is the
/// main diagonal, k < 0 is below it and k > 0 is above.
///
///
/// Lower triangle of m, of same shape and data-type as m.
///
public static NDarray tril(T[] m, int? k = 0)
=> NumPy.Instance.tril(m, k:k);
///
/// Lower triangle of an array.
///
/// Return a copy of an array with elements above the k-th diagonal zeroed.
///
///
/// Input array.
///
///
/// Diagonal above which to zero elements.
/// k = 0 (the default) is the
/// main diagonal, k < 0 is below it and k > 0 is above.
///
///
/// Lower triangle of m, of same shape and data-type as m.
///
public static NDarray tril(T[,] m, int? k = 0)
=> NumPy.Instance.tril(m, k:k);
///
/// Generate a Vandermonde matrix.
///
/// The columns of the output matrix are powers of the input vector.
/// The
/// order of the powers is determined by the increasing boolean argument.
///
/// Specifically, when increasing is False, the i-th output column is
/// the input vector raised element-wise to the power of N - i - 1.
/// Such
/// a matrix with a geometric progression in each row is named for Alexandre-
/// Theophile Vandermonde.
///
///
/// 1-D input array.
///
///
/// Number of columns in the output.
/// If N is not specified, a square
/// array is returned (N = len(x)).
///
///
/// Order of the powers of the columns.
/// If True, the powers increase
/// from left to right, if False (the default) they are reversed.
///
///
/// Vandermonde matrix.
/// If increasing is False, the first column is
/// x^(N-1), the second x^(N-2) and so forth.
/// If increasing is
/// True, the columns are x^0, x^1, ..., x^(N-1).
///
public static NDarray vander(NDarray x, int? N = null, bool? increasing = false)
=> NumPy.Instance.vander(x, N:N, increasing:increasing);
///
/// Generate a Vandermonde matrix.
///
/// The columns of the output matrix are powers of the input vector.
/// The
/// order of the powers is determined by the increasing boolean argument.
///
/// Specifically, when increasing is False, the i-th output column is
/// the input vector raised element-wise to the power of N - i - 1.
/// Such
/// a matrix with a geometric progression in each row is named for Alexandre-
/// Theophile Vandermonde.
///
///
/// 1-D input array.
///
///
/// Number of columns in the output.
/// If N is not specified, a square
/// array is returned (N = len(x)).
///
///
/// Order of the powers of the columns.
/// If True, the powers increase
/// from left to right, if False (the default) they are reversed.
///
///
/// Vandermonde matrix.
/// If increasing is False, the first column is
/// x^(N-1), the second x^(N-2) and so forth.
/// If increasing is
/// True, the columns are x^0, x^1, ..., x^(N-1).
///
public static NDarray vander(T[] x, int? N = null, bool? increasing = false)
=> NumPy.Instance.vander(x, N:N, increasing:increasing);
///
/// Generate a Vandermonde matrix.
///
/// The columns of the output matrix are powers of the input vector.
/// The
/// order of the powers is determined by the increasing boolean argument.
///
/// Specifically, when increasing is False, the i-th output column is
/// the input vector raised element-wise to the power of N - i - 1.
/// Such
/// a matrix with a geometric progression in each row is named for Alexandre-
/// Theophile Vandermonde.
///
///
/// 1-D input array.
///
///
/// Number of columns in the output.
/// If N is not specified, a square
/// array is returned (N = len(x)).
///
///
/// Order of the powers of the columns.
/// If True, the powers increase
/// from left to right, if False (the default) they are reversed.
///
///
/// Vandermonde matrix.
/// If increasing is False, the first column is
/// x^(N-1), the second x^(N-2) and so forth.
/// If increasing is
/// True, the columns are x^0, x^1, ..., x^(N-1).
///
public static NDarray vander(T[,] x, int? N = null, bool? increasing = false)
=> NumPy.Instance.vander(x, N:N, increasing:increasing);
/*
///
/// Interpret the input as a matrix.
///
/// Unlike matrix, asmatrix does not make a copy if the input is already
/// a matrix or an ndarray.
/// Equivalent to matrix(data, copy=False).
///
///
/// Input data.
///
///
/// Data-type of the output matrix.
///
///
/// data interpreted as a matrix.
///
public static Matrix mat(NDarray data, Dtype dtype)
=> NumPy.Instance.mat(data, dtype);
*/
/*
///
/// Interpret the input as a matrix.
///
/// Unlike matrix, asmatrix does not make a copy if the input is already
/// a matrix or an ndarray.
/// Equivalent to matrix(data, copy=False).
///
///
/// Input data.
///
///
/// Data-type of the output matrix.
///
///
/// data interpreted as a matrix.
///
public static Matrix mat(T[] data, Dtype dtype)
=> NumPy.Instance.mat(data, dtype);
*/
/*
///
/// Interpret the input as a matrix.
///
/// Unlike matrix, asmatrix does not make a copy if the input is already
/// a matrix or an ndarray.
/// Equivalent to matrix(data, copy=False).
///
///
/// Input data.
///
///
/// Data-type of the output matrix.
///
///
/// data interpreted as a matrix.
///
public static Matrix mat(T[,] data, Dtype dtype)
=> NumPy.Instance.mat(data, dtype);
*/
/*
///
/// Build a matrix object from a string, nested sequence, or array.
///
///
/// Input data.
/// If a string, variables in the current scope may be
/// referenced by name.
///
///
/// A dictionary that replaces local operands in current frame.
///
/// Ignored if obj is not a string or gdict is None.
///
///
/// A dictionary that replaces global operands in current frame.
///
/// Ignored if obj is not a string.
///
///
/// Returns a matrix object, which is a specialized 2-D array.
///
public static Matrix bmat(string obj, Hashtable ldict = null, Hashtable gdict = null)
=> NumPy.Instance.bmat(obj, ldict:ldict, gdict:gdict);
*/
/*
///
/// Build a matrix object from a string, nested sequence, or array.
///
///
/// Input data.
/// If a string, variables in the current scope may be
/// referenced by name.
///
///
/// A dictionary that replaces local operands in current frame.
///
/// Ignored if obj is not a string or gdict is None.
///
///
/// A dictionary that replaces global operands in current frame.
///
/// Ignored if obj is not a string.
///
///
/// Returns a matrix object, which is a specialized 2-D array.
///
public static Matrix bmat(T[] obj, Hashtable ldict = null, Hashtable gdict = null)
=> NumPy.Instance.bmat(obj, ldict:ldict, gdict:gdict);
*/
}
}