Esempio n. 1
0
        public static void Run()
        {
            var input = new Input(new Keras.Shape(32, 32));
            //var a = new CuDNNLSTM(32).Set(input);
            var a = new Dense(32, activation: "sigmoid").Set(input);
            //a.Set(input);
            var output = new Dense(1, activation: "sigmoid").Set(a);
            //output.Set(a);

            var model = new Keras.Models.Model(new Input[] { input }, new BaseLayer[] { output });

            //Load train data
            Numpy.NDarray x = np.array(new float[, ] {
                { 0, 0 }, { 0, 1 }, { 1, 0 }, { 1, 1 }
            });
            NDarray y = np.array(new float[] { 0, 1, 1, 0 });

            var input1   = new Input(new Shape(32, 32, 3));
            var conv1    = new Conv2D(32, (4, 4).ToTuple(), activation: "relu").Set(input1);
            var pool1    = new MaxPooling2D((2, 2).ToTuple()).Set(conv1);
            var flatten1 = new Flatten().Set(pool1);

            var input2   = new Input(new Shape(32, 32, 3));
            var conv2    = new Conv2D(16, (8, 8).ToTuple(), activation: "relu").Set(input2);
            var pool2    = new MaxPooling2D((2, 2).ToTuple()).Set(conv2);
            var flatten2 = new Flatten().Set(pool2);

            var merge = new Concatenate(flatten1, flatten2);
        }
 /// <summary>
 ///	Evaluates the Einstein summation convention on the operands.<br></br>
 ///
 ///	Using the Einstein summation convention, many common multi-dimensional,
 ///	linear algebraic array operations can be represented in a simple fashion.<br></br>
 ///
 ///	In implicit mode einsum computes these values.<br></br>
 ///
 ///	In explicit mode, einsum provides further flexibility to compute
 ///	other array operations that might not be considered classical Einstein
 ///	summation operations, by disabling, or forcing summation over specified
 ///	subscript labels.<br></br>
 ///
 ///	See the notes and examples for clarification.<br></br>
 ///
 ///	Notes
 ///
 ///	The Einstein summation convention can be used to compute
 ///	many multi-dimensional, linear algebraic array operations.<br></br>
 ///	 einsum
 ///	provides a succinct way of representing these.<br></br>
 ///
 ///	A non-exhaustive list of these operations,
 ///	which can be computed by einsum, is shown below along with examples:
 ///
 ///	The subscripts string is a comma-separated list of subscript labels,
 ///	where each label refers to a dimension of the corresponding operand.<br></br>
 ///
 ///	Whenever a label is repeated it is summed, so np.einsum('i,i', a, b)
 ///	is equivalent to np.inner(a,b).<br></br>
 ///	 If a label
 ///	appears only once, it is not summed, so np.einsum('i', a) produces a
 ///	view of a with no changes.<br></br>
 ///	 A further example np.einsum('ij,jk', a, b)
 ///	describes traditional matrix multiplication and is equivalent to
 ///	np.matmul(a,b).<br></br>
 ///	 Repeated subscript labels in one
 ///	operand take the diagonal.<br></br>
 ///	 For example, np.einsum('ii', a) is equivalent
 ///	to np.trace(a).<br></br>
 ///
 ///	In implicit mode, the chosen subscripts are important
 ///	since the axes of the output are reordered alphabetically.<br></br>
 ///	  This
 ///	means that np.einsum('ij', a) doesn’t affect a 2D array, while
 ///	np.einsum('ji', a) takes its transpose.<br></br>
 ///	 Additionally,
 ///	np.einsum('ij,jk', a, b) returns a matrix multiplication, while,
 ///	np.einsum('ij,jh', a, b) returns the transpose of the
 ///	multiplication since subscript ‘h’ precedes subscript ‘i’.
 ///
 ///	In explicit mode the output can be directly controlled by
 ///	specifying output subscript labels.<br></br>
 ///	  This requires the
 ///	identifier ‘-&gt;’ as well as the list of output subscript labels.<br></br>
 ///
 ///	This feature increases the flexibility of the function since
 ///	summing can be disabled or forced when required.<br></br>
 ///	 The call
 ///	np.einsum('i-&gt;', a) is like np.sum(a, axis=-1),
 ///	and np.einsum('ii-&gt;i', a) is like np.diag(a).<br></br>
 ///
 ///	The difference is that einsum does not allow broadcasting by default.<br></br>
 ///
 ///	Additionally np.einsum('ij,jh-&gt;ih', a, b) directly specifies the
 ///	order of the output subscript labels and therefore returns matrix
 ///	multiplication, unlike the example above in implicit mode.<br></br>
 ///
 ///	To enable and control broadcasting, use an ellipsis.<br></br>
 ///	  Default
 ///	NumPy-style broadcasting is done by adding an ellipsis
 ///	to the left of each term, like np.einsum('...ii-&gt;...i', a).<br></br>
 ///
 ///	To take the trace along the first and last axes,
 ///	you can do np.einsum('i...i', a), or to do a matrix-matrix
 ///	product with the left-most indices instead of rightmost, one can do
 ///	np.einsum('ij...,jk...-&gt;ik...', a, b).<br></br>
 ///
 ///	When there is only one operand, no axes are summed, and no output
 ///	parameter is provided, a view into the operand is returned instead
 ///	of a new array.<br></br>
 ///	  Thus, taking the diagonal as np.einsum('ii-&gt;i', a)
 ///	produces a view (changed in version 1.10.0).<br></br>
 ///
 ///	einsum also provides an alternative way to provide the subscripts
 ///	and operands as einsum(op0, sublist0, op1, sublist1, ..., [sublistout]).<br></br>
 ///
 ///	If the output shape is not provided in this format einsum will be
 ///	calculated in implicit mode, otherwise it will be performed explicitly.<br></br>
 ///
 ///	The examples below have corresponding einsum calls with the two
 ///	parameter methods.<br></br>
 ///
 ///	Views returned from einsum are now writeable whenever the input array
 ///	is writeable.<br></br>
 ///	 For example, np.einsum('ijk...-&gt;kji...', a) will now
 ///	have the same effect as np.swapaxes(a, 0, 2)
 ///	and np.einsum('ii-&gt;i', a) will return a writeable view of the diagonal
 ///	of a 2D array.<br></br>
 ///
 ///	Added the optimize argument which will optimize the contraction order
 ///	of an einsum expression.<br></br>
 ///	 For a contraction with three or more operands this
 ///	can greatly increase the computational efficiency at the cost of a larger
 ///	memory footprint during computation.<br></br>
 ///
 ///	Typically a ‘greedy’ algorithm is applied which empirical tests have shown
 ///	returns the optimal path in the majority of cases.<br></br>
 ///	 In some cases ‘optimal’
 ///	will return the superlative path through a more expensive, exhaustive search.<br></br>
 ///
 ///	For iterative calculations it may be advisable to calculate the optimal path
 ///	once and reuse that path by supplying it as an argument.<br></br>
 ///	 An example is given
 ///	below.<br></br>
 ///
 ///	See numpy.einsum_path for more details.
 /// </summary>
 /// <param name="subscripts">
 ///	Specifies the subscripts for summation as comma separated list of
 ///	subscript labels.<br></br>
 ///	An implicit (classical Einstein summation)
 ///	calculation is performed unless the explicit indicator ‘-&gt;’ is
 ///	included as well as subscript labels of the precise output form.
 /// </param>
 /// <param name="operands">
 ///	These are the arrays for the operation.
 /// </param>
 /// <param name="out">
 ///	If provided, the calculation is done into this array.
 /// </param>
 /// <param name="dtype">
 ///	If provided, forces the calculation to use the data type specified.<br></br>
 ///
 ///	Note that you may have to also give a more liberal casting
 ///	parameter to allow the conversions.<br></br>
 ///	Default is None.
 /// </param>
 /// <param name="order">
 ///	Controls the memory layout of the output.<br></br>
 ///	‘C’ means it should
 ///	be C contiguous.<br></br>
 ///	‘F’ means it should be Fortran contiguous,
 ///	‘A’ means it should be ‘F’ if the inputs are all ‘F’, ‘C’ otherwise.<br></br>
 ///
 ///	‘K’ means it should be as close to the layout as the inputs as
 ///	is possible, including arbitrarily permuted axes.<br></br>
 ///
 ///	Default is ‘K’.
 /// </param>
 /// <param name="casting">
 ///	Controls what kind of data casting may occur.<br></br>
 ///	Setting this to
 ///	‘unsafe’ is not recommended, as it can adversely affect accumulations.<br></br>
 ///
 ///	Default is ‘safe’.
 /// </param>
 /// <param name="optimize">
 ///	Controls if intermediate optimization should occur.<br></br>
 ///	No optimization
 ///	will occur if False and True will default to the ‘greedy’ algorithm.<br></br>
 ///
 ///	Also accepts an explicit contraction list from the np.einsum_path
 ///	function.<br></br>
 ///	See np.einsum_path for more details.<br></br>
 ///	Defaults to False.
 /// </param>
 /// <returns>
 ///	The calculation based on the Einstein summation convention.
 /// </returns>
 public static NDarray einsum(string subscripts, NDarray[] operands, NDarray @out = null, Dtype dtype = null, string order = null, string casting = "safe", object optimize = null)
 => NumPy.Instance.einsum(subscripts, operands, @out: @out, dtype: dtype, order: order, casting: casting, optimize: optimize);
Esempio n. 3
0
        /***************************************************/

        public static np.NDarray Slice(this np.NDarray array, np.NDarray notation)
        {
            return(array[notation]);
        }
Esempio n. 4
0
 /// <summary>
 ///	Test whether all array elements along a given axis evaluate to True.<br></br>
 ///
 ///	Notes
 ///
 ///	Not a Number (NaN), positive infinity and negative infinity
 ///	evaluate to True because these are not equal to zero.
 /// </summary>
 /// <param name="a">
 ///	Input array or object that can be converted to an array.
 /// </param>
 /// <returns>
 ///	A new boolean or array is returned unless out is specified,
 ///	in which case a reference to out is returned.
 /// </returns>
 public static bool all(NDarray a)
 => NumPy.Instance.all(a);
Esempio n. 5
0
 /// <summary>
 ///	Return (x1 != x2) element-wise.
 /// </summary>
 /// <param name="x2">
 ///	Input arrays.
 /// </param>
 /// <param name="x1">
 ///	Input arrays.
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	Output array, element-wise comparison of x1 and x2.
 ///	Typically of type bool, unless dtype=object is passed.<br></br>
 ///
 ///	This is a scalar if both x1 and x2 are scalars.
 /// </returns>
 public static NDarray not_equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.not_equal(x2, x1, @out: @out, @where: @where);
Esempio n. 6
0
 /// <summary>
 ///	Returns a boolean array where two arrays are element-wise equal within a
 ///	tolerance.<br></br>
 ///
 ///	The tolerance values are positive, typically very small numbers.<br></br>
 ///	  The
 ///	relative difference (rtol * abs(b)) and the absolute difference
 ///	atol are added together to compare against the absolute difference
 ///	between a and b.<br></br>
 ///
 ///	Notes
 ///
 ///	For finite values, isclose uses the following equation to test whether
 ///	two floating point values are equivalent.<br></br>
 ///
 ///	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).<br></br>
 ///	 Furthermore,
 ///	the default value of atol is not zero, and is used to determine what
 ///	small values should be considered close to zero.<br></br>
 ///	 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.<br></br>
 ///
 ///	atol should be carefully selected for the use case at hand.<br></br>
 ///	 A zero value
 ///	for atol will result in False if either a or b is zero.
 /// </summary>
 /// <param name="b">
 ///	Input arrays to compare.
 /// </param>
 /// <param name="a">
 ///	Input arrays to compare.
 /// </param>
 /// <param name="rtol">
 ///	The relative tolerance parameter (see Notes).
 /// </param>
 /// <param name="atol">
 ///	The absolute tolerance parameter (see Notes).
 /// </param>
 /// <param name="equal_nan">
 ///	Whether to compare NaN’s as equal.<br></br>
 ///	If True, NaN’s in a will be
 ///	considered equal to NaN’s in b in the output array.
 /// </param>
 /// <returns>
 ///	Returns a boolean array of where a and b are equal within the
 ///	given tolerance.<br></br>
 ///	 If both a and b are scalars, returns a single
 ///	boolean value.
 /// </returns>
 public static NDarray isclose(NDarray b, NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false)
 => NumPy.Instance.isclose(b, a, rtol: rtol, atol: atol, equal_nan: equal_nan);
Esempio n. 7
0
 /// <summary>
 ///	Return the truth value of (x1 &gt; x2) element-wise.
 /// </summary>
 /// <param name="x2">
 ///	Input arrays.<br></br>
 ///	If x1.shape != x2.shape, they must be
 ///	broadcastable to a common shape (which may be the shape of one or
 ///	the other).
 /// </param>
 /// <param name="x1">
 ///	Input arrays.<br></br>
 ///	If x1.shape != x2.shape, they must be
 ///	broadcastable to a common shape (which may be the shape of one or
 ///	the other).
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	Output array, element-wise comparison of x1 and x2.
 ///	Typically of type bool, unless dtype=object is passed.<br></br>
 ///
 ///	This is a scalar if both x1 and x2 are scalars.
 /// </returns>
 public static NDarray greater(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.greater(x2, x1, @out: @out, @where: @where);
Esempio n. 8
0
 /// <summary>
 ///	Test element-wise for positive or negative infinity.<br></br>
 ///
 ///	Returns a boolean array of the same shape as x, True where x ==
 ///	+/-inf, otherwise False.<br></br>
 ///
 ///	Notes
 ///
 ///	NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
 ///	(IEEE 754).<br></br>
 ///
 ///	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.
 /// </summary>
 /// <param name="x">
 ///	Input values
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	True where x is positive or negative infinity, false otherwise.<br></br>
 ///
 ///	This is a scalar if x is a scalar.
 /// </returns>
 public static NDarray <bool> isinf(NDarray x, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.isinf(x, @out: @out, @where: @where);
Esempio n. 9
0
 /// <summary>
 ///	Test element-wise for NaT (not a time) and return result as a boolean array.
 /// </summary>
 /// <param name="x">
 ///	Input array with datetime or timedelta data type.
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	True where x is NaT, false otherwise.<br></br>
 ///
 ///	This is a scalar if x is a scalar.
 /// </returns>
 public static NDarray isnat(NDarray x, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.isnat(x, @out: @out, @where: @where);
Esempio n. 10
0
        /// <summary>
        ///	Return the sum along diagonals of the array.<br></br>
        ///
        ///	If a is 2-D, the sum along its diagonal with the given offset
        ///	is returned, i.e., the sum of elements a[i,i+offset] for all i.<br></br>
        ///
        ///	If a has more than two dimensions, then the axes specified by axis1 and
        ///	axis2 are used to determine the 2-D sub-arrays whose traces are returned.<br></br>
        ///
        ///	The shape of the resulting array is the same as that of a with axis1
        ///	and axis2 removed.
        /// </summary>
        /// <param name="a">
        ///	Input array, from which the diagonals are taken.
        /// </param>
        /// <param name="offset">
        ///	Offset of the diagonal from the main diagonal.<br></br>
        ///	Can be both positive
        ///	and negative.<br></br>
        ///	Defaults to 0.
        /// </param>
        /// <param name="axis2">
        ///	Axes to be used as the first and second axis of the 2-D sub-arrays
        ///	from which the diagonals should be taken.<br></br>
        ///	Defaults are the first two
        ///	axes of a.
        /// </param>
        /// <param name="axis1">
        ///	Axes to be used as the first and second axis of the 2-D sub-arrays
        ///	from which the diagonals should be taken.<br></br>
        ///	Defaults are the first two
        ///	axes of a.
        /// </param>
        /// <param name="dtype">
        ///	Determines the data-type of the returned array and of the accumulator
        ///	where the elements are summed.<br></br>
        ///	If dtype has the value None and a is
        ///	of integer type of precision less than the default integer
        ///	precision, then the default integer precision is used.<br></br>
        ///	Otherwise,
        ///	the precision is the same as that of a.
        /// </param>
        /// <param name="out">
        ///	Array into which the output is placed.<br></br>
        ///	Its type is preserved and
        ///	it must be of the right shape to hold the output.
        /// </param>
        /// <returns>
        ///	If a is 2-D, the sum along the diagonal is returned.<br></br>
        ///	  If a has
        ///	larger dimensions, then an array of sums along diagonals is returned.
        /// </returns>
        public static NDarray trace(NDarray a, int?offset = 0, int?axis2 = null, int?axis1 = null, Dtype dtype = null, NDarray @out = null)
        {
            //auto-generated code, do not change
            var __self__ = self;
            var pyargs   = ToTuple(new object[]
            {
                a,
            });
            var kwargs = new PyDict();

            if (offset != 0)
            {
                kwargs["offset"] = ToPython(offset);
            }
            if (axis2 != null)
            {
                kwargs["axis2"] = ToPython(axis2);
            }
            if (axis1 != null)
            {
                kwargs["axis1"] = ToPython(axis1);
            }
            if (dtype != null)
            {
                kwargs["dtype"] = ToPython(dtype);
            }
            if (@out != null)
            {
                kwargs["out"] = ToPython(@out);
            }
            dynamic py = __self__.InvokeMethod("trace", pyargs, kwargs);

            return(ToCsharp <NDarray>(py));
        }
Esempio n. 11
0
 /// <summary>
 ///	Test whether any array element along a given axis evaluates to True.<br></br>
 ///
 ///	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.
 /// </summary>
 /// <param name="a">
 ///	Input array or object that can be converted to an array.
 /// </param>
 /// <returns>
 ///	A new boolean or ndarray is returned unless out is specified,
 ///	in which case a reference to out is returned.
 /// </returns>
 public static bool any(NDarray a)
 => NumPy.Instance.any(a);
Esempio n. 12
0
 /// <summary>
 ///	Return the sum along diagonals of the array.<br></br>
 ///
 ///	If a is 2-D, the sum along its diagonal with the given offset
 ///	is returned, i.e., the sum of elements a[i,i+offset] for all i.<br></br>
 ///
 ///	If a has more than two dimensions, then the axes specified by axis1 and
 ///	axis2 are used to determine the 2-D sub-arrays whose traces are returned.<br></br>
 ///
 ///	The shape of the resulting array is the same as that of a with axis1
 ///	and axis2 removed.
 /// </summary>
 /// <param name="a">
 ///	Input array, from which the diagonals are taken.
 /// </param>
 /// <param name="offset">
 ///	Offset of the diagonal from the main diagonal.<br></br>
 ///	Can be both positive
 ///	and negative.<br></br>
 ///	Defaults to 0.
 /// </param>
 /// <param name="axis2">
 ///	Axes to be used as the first and second axis of the 2-D sub-arrays
 ///	from which the diagonals should be taken.<br></br>
 ///	Defaults are the first two
 ///	axes of a.
 /// </param>
 /// <param name="axis1">
 ///	Axes to be used as the first and second axis of the 2-D sub-arrays
 ///	from which the diagonals should be taken.<br></br>
 ///	Defaults are the first two
 ///	axes of a.
 /// </param>
 /// <param name="dtype">
 ///	Determines the data-type of the returned array and of the accumulator
 ///	where the elements are summed.<br></br>
 ///	If dtype has the value None and a is
 ///	of integer type of precision less than the default integer
 ///	precision, then the default integer precision is used.<br></br>
 ///	Otherwise,
 ///	the precision is the same as that of a.
 /// </param>
 /// <param name="out">
 ///	Array into which the output is placed.<br></br>
 ///	Its type is preserved and
 ///	it must be of the right shape to hold the output.
 /// </param>
 /// <returns>
 ///	If a is 2-D, the sum along the diagonal is returned.<br></br>
 ///	  If a has
 ///	larger dimensions, then an array of sums along diagonals is returned.
 /// </returns>
 public static NDarray trace(NDarray a, int?offset = 0, int?axis2 = null, int?axis1 = null, Dtype dtype = null, NDarray @out = null)
 => NumPy.Instance.trace(a, offset: offset, axis2: axis2, axis1: axis1, dtype: dtype, @out: @out);
Esempio n. 13
0
 /// <summary>
 ///	Kronecker product of two arrays.<br></br>
 ///
 ///	Computes the Kronecker product, a composite array made of blocks of the
 ///	second array scaled by the first.<br></br>
 ///
 ///	Notes
 ///
 ///	The function assumes that the number of dimensions of a and b
 ///	are the same, if necessary prepending the smallest with ones.<br></br>
 ///
 ///	If a.shape = (r0,r1,..,rN) and b.shape = (s0,s1,…,sN),
 ///	the Kronecker product has shape (r0*s0, r1*s1, …, rN*SN).<br></br>
 ///
 ///	The elements are products of elements from a and b, organized
 ///	explicitly by:
 ///
 ///	where:
 ///
 ///	In the common 2-D case (N=1), the block structure can be visualized:
 /// </summary>
 public static NDarray kron(NDarray b, NDarray a)
 => NumPy.Instance.kron(b, a);
Esempio n. 14
0
 /// <summary>
 ///	Dot product of two arrays.<br></br>
 ///	 Specifically,
 /// </summary>
 /// <param name="a">
 ///	First argument.
 /// </param>
 /// <param name="b">
 ///	Second argument.
 /// </param>
 /// <param name="out">
 ///	Output argument.<br></br>
 ///	This must have the exact kind that would be returned
 ///	if it was not used.<br></br>
 ///	In particular, it must have the right type, must be
 ///	C-contiguous, and its dtype must be the dtype that would be returned
 ///	for dot(a,b).<br></br>
 ///	This is a performance feature.<br></br>
 ///	Therefore, if these
 ///	conditions are not met, an exception is raised, instead of attempting
 ///	to be flexible.
 /// </param>
 /// <returns>
 ///	Returns the dot product of a and b.<br></br>
 ///	  If a and b are both
 ///	scalars or both 1-D arrays then a scalar is returned; otherwise
 ///	an array is returned.<br></br>
 ///
 ///	If out is given, then it is returned.
 /// </returns>
 public static NDarray dot(NDarray a, NDarray b, NDarray @out = null)
 => NumPy.Instance.dot(a, b, @out: @out);
Esempio n. 15
0
 /// <summary>
 ///	Compute the truth value of x1 XOR x2, element-wise.
 /// </summary>
 /// <param name="x2">
 ///	Logical XOR is applied to the elements of x1 and x2.  They must
 ///	be broadcastable to the same shape.
 /// </param>
 /// <param name="x1">
 ///	Logical XOR is applied to the elements of x1 and x2.  They must
 ///	be broadcastable to the same shape.
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	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.<br></br>
 ///
 ///	This is a scalar if both x1 and x2 are scalars.
 /// </returns>
 public static NDarray <bool> logical_xor(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.logical_xor(x2, x1, @out: @out, @where: @where);
Esempio n. 16
0
 /// <summary>
 ///	Test element-wise for negative infinity, return result as bool array.<br></br>
 ///
 ///	Notes
 ///
 ///	NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
 ///	(IEEE 754).<br></br>
 ///
 ///	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.
 /// </summary>
 /// <param name="x">
 ///	The input array.
 /// </param>
 /// <param name="out">
 ///	A boolean array with the same shape and type as x to store the
 ///	result.
 /// </param>
 /// <returns>
 ///	A boolean array with the same dimensions as the input.<br></br>
 ///
 ///	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.<br></br>
 ///
 ///	If a second argument is supplied the result is stored there.<br></br>
 ///	 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.<br></br>
 ///	 The
 ///	return value out is then a reference to that array.
 /// </returns>
 public static NDarray isneginf(NDarray x, NDarray @out = null)
 => NumPy.Instance.isneginf(x, @out: @out);
Esempio n. 17
0
 /// <summary>
 ///	Test whether all array elements along a given axis evaluate to True.<br></br>
 ///
 ///	Notes
 ///
 ///	Not a Number (NaN), positive infinity and negative infinity
 ///	evaluate to True because these are not equal to zero.
 /// </summary>
 /// <param name="a">
 ///	Input array or object that can be converted to an array.
 /// </param>
 /// <param name="axis">
 ///	Axis or axes along which a logical AND reduction is performed.<br></br>
 ///
 ///	The default (axis = None) is to perform a logical AND over all
 ///	the dimensions of the input array.<br></br>
 ///	axis may be negative, in
 ///	which case it counts from the last to the first axis.<br></br>
 ///
 ///	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.
 /// </param>
 /// <param name="out">
 ///	Alternate output array in which to place the result.<br></br>
 ///
 ///	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).<br></br>
 ///	See doc.ufuncs (Section
 ///	“Output arguments”) for more details.
 /// </param>
 /// <param name="keepdims">
 ///	If this is set to True, the axes which are reduced are left
 ///	in the result as dimensions with size one.<br></br>
 ///	With this option,
 ///	the result will broadcast correctly against the input array.<br></br>
 ///
 ///	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.<br></br>
 ///	If the
 ///	sub-class’ method does not implement keepdims any
 ///	exceptions will be raised.
 /// </param>
 /// <returns>
 ///	A new boolean or array is returned unless out is specified,
 ///	in which case a reference to out is returned.
 /// </returns>
 public static NDarray <bool> all(NDarray a, int[] axis, NDarray @out = null, bool?keepdims = null)
 => NumPy.Instance.all(a, axis: axis, @out: @out, keepdims: keepdims);
Esempio n. 18
0
 /// <summary>
 ///	Test element-wise for positive infinity, return result as bool array.<br></br>
 ///
 ///	Notes
 ///
 ///	NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
 ///	(IEEE 754).<br></br>
 ///
 ///	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
 /// </summary>
 /// <param name="x">
 ///	The input array.
 /// </param>
 /// <param name="y">
 ///	A boolean array with the same shape as x to store the result.
 /// </param>
 /// <returns>
 ///	A boolean array with the same dimensions as the input.<br></br>
 ///
 ///	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.<br></br>
 ///
 ///	If a second argument is supplied the result is stored there.<br></br>
 ///	 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.<br></br>
 ///
 ///	The return value out is then a reference to that array.
 /// </returns>
 public static NDarray isposinf(NDarray x, NDarray y = null)
 => NumPy.Instance.isposinf(x, y: y);
Esempio n. 19
0
 /// <summary>
 ///	Returns True if input arrays are shape consistent and all elements equal.<br></br>
 ///
 ///	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.
 /// </summary>
 /// <param name="a2">
 ///	Input arrays.
 /// </param>
 /// <param name="a1">
 ///	Input arrays.
 /// </param>
 /// <returns>
 ///	True if equivalent, False otherwise.
 /// </returns>
 public static bool array_equiv(NDarray a2, NDarray a1)
 => NumPy.Instance.array_equiv(a2, a1);
Esempio n. 20
0
 /// <summary>
 ///	Returns a bool array, where True if input element is complex.<br></br>
 ///
 ///	What is tested is whether the input has a non-zero imaginary part, not if
 ///	the input type is complex.
 /// </summary>
 /// <param name="x">
 ///	Input array.
 /// </param>
 /// <returns>
 ///	Output array.
 /// </returns>
 public static NDarray iscomplex(NDarray x)
 => NumPy.Instance.iscomplex(x);
Esempio n. 21
0
 /// <summary>
 ///	Return the truth value of (x1 &gt;= x2) element-wise.
 /// </summary>
 /// <param name="x2">
 ///	Input arrays.<br></br>
 ///	If x1.shape != x2.shape, they must be
 ///	broadcastable to a common shape (which may be the shape of one or
 ///	the other).
 /// </param>
 /// <param name="x1">
 ///	Input arrays.<br></br>
 ///	If x1.shape != x2.shape, they must be
 ///	broadcastable to a common shape (which may be the shape of one or
 ///	the other).
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	Output array, element-wise comparison of x1 and x2.
 ///	Typically of type bool, unless dtype=object is passed.<br></br>
 ///
 ///	This is a scalar if both x1 and x2 are scalars.
 /// </returns>
 public static NDarray <bool> greater_equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.greater_equal(x2, x1, @out: @out, @where: @where);
Esempio n. 22
0
 /// <summary>
 ///	Returns True if the array is Fortran contiguous but not C contiguous.<br></br>
 ///
 ///	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 &gt;= 1.10.0 and previous versions.<br></br>
 ///	 If you only want to check if an
 ///	array is Fortran contiguous use a.flags.f_contiguous instead.
 /// </summary>
 /// <param name="a">
 ///	Input array.
 /// </param>
 public static bool isfortran(NDarray a)
 => NumPy.Instance.isfortran(a);
Esempio n. 23
0
 /// <summary>
 ///	Return the truth value of (x1 &lt; x2) element-wise.
 /// </summary>
 /// <param name="x2">
 ///	Input arrays.<br></br>
 ///	If x1.shape != x2.shape, they must be
 ///	broadcastable to a common shape (which may be the shape of one or
 ///	the other).
 /// </param>
 /// <param name="x1">
 ///	Input arrays.<br></br>
 ///	If x1.shape != x2.shape, they must be
 ///	broadcastable to a common shape (which may be the shape of one or
 ///	the other).
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	Output array, element-wise comparison of x1 and x2.
 ///	Typically of type bool, unless dtype=object is passed.<br></br>
 ///
 ///	This is a scalar if both x1 and x2 are scalars.
 /// </returns>
 public static NDarray less(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.less(x2, x1, @out: @out, @where: @where);
Esempio n. 24
0
 /// <summary>
 ///	Returns a bool array, where True if input element is real.<br></br>
 ///
 ///	If element has complex type with zero complex part, the return value
 ///	for that element is True.
 /// </summary>
 /// <param name="x">
 ///	Input array.
 /// </param>
 /// <returns>
 ///	Boolean array of same shape as x.
 /// </returns>
 public static NDarray isreal(NDarray x)
 => NumPy.Instance.isreal(x);
Esempio n. 25
0
 public NDarray(NDarray t) : base((PyObject)t.PyObject)
 {
 }
Esempio n. 26
0
 /// <summary>
 ///	Compute the truth value of x1 AND x2 element-wise.
 /// </summary>
 /// <param name="x2">
 ///	Input arrays.<br></br>
 ///	x1 and x2 must be of the same shape.
 /// </param>
 /// <param name="x1">
 ///	Input arrays.<br></br>
 ///	x1 and x2 must be of the same shape.
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	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.
 /// </returns>
 public static NDarray logical_and(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.logical_and(x2, x1, @out: @out, @where: @where);
Esempio n. 27
0
        /***************************************************/
        /**** Public Methods                            ****/
        /***************************************************/

        public static np.NDarray Slice(this np.NDarray array, string sliceNotation)
        {
            return(array[sliceNotation]);
        }
Esempio n. 28
0
 /// <summary>
 ///	Compute the truth value of NOT x element-wise.
 /// </summary>
 /// <param name="x">
 ///	Logical NOT is applied to the elements of x.
 /// </param>
 /// <param name="out">
 ///	A location into which the result is stored.<br></br>
 ///	If provided, it must have
 ///	a shape that the inputs broadcast to.<br></br>
 ///	If not provided or None,
 ///	a freshly-allocated array is returned.<br></br>
 ///	A tuple (possible only as a
 ///	keyword argument) must have length equal to the number of outputs.
 /// </param>
 /// <param name="where">
 ///	Values of True indicate to calculate the ufunc at that position, values
 ///	of False indicate to leave the value in the output alone.
 /// </param>
 /// <returns>
 ///	Boolean result with the same shape as x of the NOT operation
 ///	on elements of x.<br></br>
 ///
 ///	This is a scalar if x is a scalar.
 /// </returns>
 public static NDarray <bool> logical_not(NDarray x, NDarray @out = null, NDarray @where = null)
 => NumPy.Instance.logical_not(x, @out: @out, @where: @where);
Esempio n. 29
0
        /***************************************************/

        public static np.NDarray ISlice(this np.NDarray array, object[] slice)
        {
            return(array[slice as dynamic]);
        }
Esempio n. 30
0
 /// <summary>
 ///	Compute tensor dot product along specified axes for arrays &gt;= 1-D.<br></br>
 ///
 ///	Given two tensors (arrays of dimension greater than or equal to one),
 ///	a and b, and an array_like object containing two array_like
 ///	objects, (a_axes, b_axes), sum the products of a’s and b’s
 ///	elements (components) over the axes specified by a_axes and
 ///	b_axes.<br></br>
 ///	 The third argument can be a single non-negative
 ///	integer_like scalar, N; if it is such, then the last N
 ///	dimensions of a and the first N dimensions of b are summed
 ///	over.<br></br>
 ///
 ///	Notes
 ///
 ///	When axes is integer_like, the sequence for evaluation will be: first
 ///	the -Nth axis in a and 0th axis in b, and the -1th axis in a and
 ///	Nth axis in b last.<br></br>
 ///
 ///	When there is more than one axis to sum over - and they are not the last
 ///	(first) axes of a (b) - the argument axes should consist of
 ///	two sequences of the same length, with the first axis to sum over given
 ///	first in both sequences, the second axis second, and so forth.
 /// </summary>
 /// <param name="b">
 ///	Tensors to “dot”.
 /// </param>
 /// <param name="a">
 ///	Tensors to “dot”.
 /// </param>
 public static NDarray tensordot(NDarray b, NDarray a, int[] axes = null)
 => NumPy.Instance.tensordot(b, a, axes: axes);