// 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 partial class NumPy
{
///
/// Test whether all array elements along a given axis evaluate to True.
///
/// Notes
///
/// Not a Number (NaN), positive infinity and negative infinity
/// evaluate to True because these are not equal to zero.
///
///
/// Input array or object that can be converted to an array.
///
///
/// Axis or axes along which a logical AND reduction is performed.
///
/// The default (axis = None) is to perform a logical AND over all
/// the dimensions of the input array.
/// axis may be negative, in
/// which case it counts from the last to the first axis.
///
/// If this is a tuple of ints, a reduction is performed on multiple
/// axes, instead of a single axis or all the axes as before.
///
///
/// Alternate output array in which to place the result.
///
/// It must have the same shape as the expected output and its
/// type is preserved (e.g., if dtype(out) is float, the result
/// will consist of 0.0’s and 1.0’s).
/// See doc.ufuncs (Section
/// “Output arguments”) for more details.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the input array.
///
/// If the default value is passed, then keepdims will not be
/// passed through to the all method of sub-classes of
/// ndarray, however any non-default value will be.
/// If the
/// sub-class’ method does not implement keepdims any
/// exceptions will be raised.
///
///
/// A new boolean or array is returned unless out is specified,
/// in which case a reference to out is returned.
///
public NDarray all(NDarray a, int[] axis, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a,
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (@out!=null) kwargs["out"]=ToPython(@out);
if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);
dynamic py = __self__.InvokeMethod("all", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Test whether all array elements along a given axis evaluate to True.
///
/// Notes
///
/// Not a Number (NaN), positive infinity and negative infinity
/// evaluate to True because these are not equal to zero.
///
///
/// Input array or object that can be converted to an array.
///
///
/// A new boolean or array is returned unless out is specified,
/// in which case a reference to out is returned.
///
public bool all(NDarray a)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("all", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test whether any array element along a given axis evaluates to True.
///
/// Returns single boolean unless axis is not None
///
/// Notes
///
/// Not a Number (NaN), positive infinity and negative infinity evaluate
/// to True because these are not equal to zero.
///
///
/// Input array or object that can be converted to an array.
///
///
/// Axis or axes along which a logical OR reduction is performed.
///
/// The default (axis = None) is to perform a logical OR over all
/// the dimensions of the input array.
/// axis may be negative, in
/// which case it counts from the last to the first axis.
///
/// If this is a tuple of ints, a reduction is performed on multiple
/// axes, instead of a single axis or all the axes as before.
///
///
/// Alternate output array in which to place the result.
/// It must have
/// the same shape as the expected output and its type is preserved
/// (e.g., if it is of type float, then it will remain so, returning
/// 1.0 for True and 0.0 for False, regardless of the type of a).
///
/// See doc.ufuncs (Section “Output arguments”) for details.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the input array.
///
/// If the default value is passed, then keepdims will not be
/// passed through to the any method of sub-classes of
/// ndarray, however any non-default value will be.
/// If the
/// sub-class’ method does not implement keepdims any
/// exceptions will be raised.
///
///
/// A new boolean or ndarray is returned unless out is specified,
/// in which case a reference to out is returned.
///
public NDarray any(NDarray a, int[] axis, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a,
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (@out!=null) kwargs["out"]=ToPython(@out);
if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);
dynamic py = __self__.InvokeMethod("any", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Test whether any array element along a given axis evaluates to True.
///
/// Returns single boolean unless axis is not None
///
/// Notes
///
/// Not a Number (NaN), positive infinity and negative infinity evaluate
/// to True because these are not equal to zero.
///
///
/// Input array or object that can be converted to an array.
///
///
/// A new boolean or ndarray is returned unless out is specified,
/// in which case a reference to out is returned.
///
public bool any(NDarray a)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("any", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for finiteness (not infinity or not Not a Number).
///
/// The result is returned as a boolean array.
///
/// Notes
///
/// Not a Number, positive infinity and negative infinity are considered
/// to be non-finite.
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
/// This means that Not a Number is not equivalent to infinity.
///
/// Also that positive infinity is not equivalent to negative infinity.
/// But
/// infinity is equivalent to positive infinity.
/// Errors result if the
/// second argument is also supplied when x is a scalar input, or if
/// first and second arguments have different shapes.
///
///
/// Input values.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// True where x is not positive infinity, negative infinity,
/// or NaN; false otherwise.
///
/// This is a scalar if x is a scalar.
///
public NDarray isfinite(NDarray x, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("isfinite", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for positive or negative infinity.
///
/// Returns a boolean array of the same shape as x, True where x ==
/// +/-inf, otherwise False.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
///
/// Errors result if the second argument is supplied when the first
/// argument is a scalar, or if the first and second arguments have
/// different shapes.
///
///
/// Input values
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// True where x is positive or negative infinity, false otherwise.
///
/// This is a scalar if x is a scalar.
///
public NDarray isinf(NDarray x, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("isinf", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Test element-wise for NaN and return result as a boolean array.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
/// This means that Not a Number is not equivalent to infinity.
///
///
/// Input array.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// True where x is NaN, false otherwise.
///
/// This is a scalar if x is a scalar.
///
public NDarray isnan(NDarray x, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("isnan", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for NaT (not a time) and return result as a boolean array.
///
///
/// Input array with datetime or timedelta data type.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// True where x is NaT, false otherwise.
///
/// This is a scalar if x is a scalar.
///
public NDarray isnat(NDarray x, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("isnat", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for negative infinity, return result as bool array.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
///
/// Errors result if the second argument is also supplied when x is a scalar
/// input, if first and second arguments have different shapes, or if the
/// first argument has complex values.
///
///
/// The input array.
///
///
/// A boolean array with the same shape and type as x to store the
/// result.
///
///
/// A boolean array with the same dimensions as the input.
///
/// If second argument is not supplied then a numpy boolean array is
/// returned with values True where the corresponding element of the
/// input is negative infinity and values False where the element of
/// the input is not negative infinity.
///
/// If a second argument is supplied the result is stored there.
/// If the
/// type of that array is a numeric type the result is represented as
/// zeros and ones, if the type is boolean then as False and True.
/// The
/// return value out is then a reference to that array.
///
public NDarray isneginf(NDarray x, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("isneginf", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for positive infinity, return result as bool array.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
///
/// Errors result if the second argument is also supplied when x is a scalar
/// input, if first and second arguments have different shapes, or if the
/// first argument has complex values
///
///
/// The input array.
///
///
/// A boolean array with the same shape as x to store the result.
///
///
/// A boolean array with the same dimensions as the input.
///
/// If second argument is not supplied then a boolean array is returned
/// with values True where the corresponding element of the input is
/// positive infinity and values False where the element of the input is
/// not positive infinity.
///
/// If a second argument is supplied the result is stored there.
/// If the
/// type of that array is a numeric type the result is represented as zeros
/// and ones, if the type is boolean then as False and True.
///
/// The return value out is then a reference to that array.
///
public NDarray isposinf(NDarray x, NDarray y = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
if (y!=null) kwargs["y"]=ToPython(y);
dynamic py = __self__.InvokeMethod("isposinf", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns a bool array, where True if input element is complex.
///
/// What is tested is whether the input has a non-zero imaginary part, not if
/// the input type is complex.
///
///
/// Input array.
///
///
/// Output array.
///
public NDarray iscomplex(NDarray x)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("iscomplex", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Check for a complex type or an array of complex numbers.
///
/// The type of the input is checked, not the value.
/// Even if the input
/// has an imaginary part equal to zero, iscomplexobj evaluates to True.
///
///
/// The input can be of any type and shape.
///
///
/// The return value, True if x is of a complex type or has at least
/// one complex element.
///
public bool iscomplexobj(object x)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("iscomplexobj", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns True if the array is Fortran contiguous but not C contiguous.
///
/// This function is obsolete and, because of changes due to relaxed stride
/// checking, its return value for the same array may differ for versions
/// of NumPy >= 1.10.0 and previous versions.
/// If you only want to check if an
/// array is Fortran contiguous use a.flags.f_contiguous instead.
///
///
/// Input array.
///
public bool isfortran(NDarray a)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("isfortran", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns a bool array, where True if input element is real.
///
/// If element has complex type with zero complex part, the return value
/// for that element is True.
///
///
/// Input array.
///
///
/// Boolean array of same shape as x.
///
public NDarray isreal(NDarray x)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("isreal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return True if x is a not complex type or an array of complex numbers.
///
/// The type of the input is checked, not the value.
/// So even if the input
/// has an imaginary part equal to zero, isrealobj evaluates to False
/// if the data type is complex.
///
///
/// The input can be of any type and shape.
///
///
/// The return value, False if x is of a complex type.
///
public bool isrealobj(object x)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("isrealobj", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns True if the type of num is a scalar type.
///
/// Notes
///
/// In almost all cases np.ndim(x) == 0 should be used instead of this
/// function, as that will also return true for 0d arrays.
/// This is how
/// numpy overloads functions in the style of the dx arguments to gradient
/// and the bins argument to histogram.
/// Some key differences:
///
///
/// Input argument, can be of any type and shape.
///
///
/// True if num is a scalar type, False if it is not.
///
public bool isscalar(object num)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
num,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("isscalar", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the truth value of x1 AND x2 element-wise.
///
///
/// Input arrays.
/// x1 and x2 must be of the same shape.
///
///
/// Input arrays.
/// x1 and x2 must be of the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Boolean result with the same shape as x1 and x2 of the logical
/// AND operation on corresponding elements of x1 and x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray logical_and(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logical_and", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the truth value of x1 OR x2 element-wise.
///
///
/// Logical OR is applied to the elements of x1 and x2.
/// They have to be of the same shape.
///
///
/// Logical OR is applied to the elements of x1 and x2.
/// They have to be of the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Boolean result with the same shape as x1 and x2 of the logical
/// OR operation on elements of x1 and x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray logical_or(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logical_or", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the truth value of NOT x element-wise.
///
///
/// Logical NOT is applied to the elements of x.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Boolean result with the same shape as x of the NOT operation
/// on elements of x.
///
/// This is a scalar if x is a scalar.
///
public NDarray logical_not(NDarray x, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logical_not", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Compute the truth value of x1 XOR x2, element-wise.
///
///
/// Logical XOR is applied to the elements of x1 and x2. They must
/// be broadcastable to the same shape.
///
///
/// Logical XOR is applied to the elements of x1 and x2. They must
/// be broadcastable to the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Boolean result of the logical XOR operation applied to the elements
/// of x1 and x2; the shape is determined by whether or not
/// broadcasting of one or both arrays was required.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray logical_xor(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logical_xor", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Returns True if two arrays are element-wise equal within a tolerance.
///
/// The tolerance values are positive, typically very small numbers.
/// The
/// relative difference (rtol * abs(b)) and the absolute difference
/// atol are added together to compare against the absolute difference
/// between a and b.
///
/// If either array contains one or more NaNs, False is returned.
///
/// Infs are treated as equal if they are in the same place and of the same
/// sign in both arrays.
///
/// Notes
///
/// If the following equation is element-wise True, then allclose returns
/// True.
///
/// The above equation is not symmetric in a and b, so that
/// allclose(a, b) might be different from allclose(b, a) in
/// some rare cases.
///
/// The comparison of a and b uses standard broadcasting, which
/// means that a and b need not have the same shape in order for
/// allclose(a, b) to evaluate to True.
/// The same is true for
/// equal but not array_equal.
///
///
/// Input arrays to compare.
///
///
/// Input arrays to compare.
///
///
/// The relative tolerance parameter (see Notes).
///
///
/// The absolute tolerance parameter (see Notes).
///
///
/// Whether to compare NaN’s as equal.
/// If True, NaN’s in a will be
/// considered equal to NaN’s in b in the output array.
///
///
/// Returns True if the two arrays are equal within the given
/// tolerance; False otherwise.
///
public bool allclose(NDarray b, NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
b,
a,
});
var kwargs=new PyDict();
if (rtol!=1e-05f) kwargs["rtol"]=ToPython(rtol);
if (atol!=1e-08f) kwargs["atol"]=ToPython(atol);
if (equal_nan!=false) kwargs["equal_nan"]=ToPython(equal_nan);
dynamic py = __self__.InvokeMethod("allclose", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns a boolean array where two arrays are element-wise equal within a
/// tolerance.
///
/// The tolerance values are positive, typically very small numbers.
/// The
/// relative difference (rtol * abs(b)) and the absolute difference
/// atol are added together to compare against the absolute difference
/// between a and b.
///
/// Notes
///
/// For finite values, isclose uses the following equation to test whether
/// two floating point values are equivalent.
///
/// Unlike the built-in math.isclose, the above equation is not symmetric
/// in a and b – it assumes b is the reference value – so that
/// isclose(a, b) might be different from isclose(b, a).
/// Furthermore,
/// the default value of atol is not zero, and is used to determine what
/// small values should be considered close to zero.
/// The default value is
/// appropriate for expected values of order unity: if the expected values
/// are significantly smaller than one, it can result in false positives.
///
/// atol should be carefully selected for the use case at hand.
/// A zero value
/// for atol will result in False if either a or b is zero.
///
///
/// Input arrays to compare.
///
///
/// Input arrays to compare.
///
///
/// The relative tolerance parameter (see Notes).
///
///
/// The absolute tolerance parameter (see Notes).
///
///
/// Whether to compare NaN’s as equal.
/// If True, NaN’s in a will be
/// considered equal to NaN’s in b in the output array.
///
///
/// Returns a boolean array of where a and b are equal within the
/// given tolerance.
/// If both a and b are scalars, returns a single
/// boolean value.
///
public NDarray isclose(NDarray b, NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
b,
a,
});
var kwargs=new PyDict();
if (rtol!=1e-05f) kwargs["rtol"]=ToPython(rtol);
if (atol!=1e-08f) kwargs["atol"]=ToPython(atol);
if (equal_nan!=false) kwargs["equal_nan"]=ToPython(equal_nan);
dynamic py = __self__.InvokeMethod("isclose", pyargs, kwargs);
return ToCsharp(py);
}
///
/// True if two arrays have the same shape and elements, False otherwise.
///
///
/// Input arrays.
///
///
/// Input arrays.
///
///
/// Returns True if the arrays are equal.
///
public bool array_equal(NDarray a2, NDarray a1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a2,
a1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("array_equal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns True if input arrays are shape consistent and all elements equal.
///
/// Shape consistent means they are either the same shape, or one input array
/// can be broadcasted to create the same shape as the other one.
///
///
/// Input arrays.
///
///
/// Input arrays.
///
///
/// True if equivalent, False otherwise.
///
public bool array_equiv(NDarray a2, NDarray a1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a2,
a1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("array_equiv", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the truth value of (x1 > x2) element-wise.
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray greater(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("greater", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the truth value of (x1 >= x2) element-wise.
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray greater_equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("greater_equal", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Return the truth value of (x1 < x2) element-wise.
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray less(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("less", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the truth value of (x1 =< x2) element-wise.
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray less_equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("less_equal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return (x1 == x2) element-wise.
///
///
/// Input arrays of the same shape.
///
///
/// Input arrays of the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("equal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return (x1 != x2) element-wise.
///
///
/// Input arrays.
///
///
/// Input arrays.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray not_equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("not_equal", pyargs, kwargs);
return ToCsharp(py);
}
}
}