// 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

{

/// <summary>

/// Trigonometric sine, element-wise.<br></br>

///

/// Notes

///

/// The sine is one of the fundamental functions of trigonometry (the

/// mathematical study of triangles).<br></br>

/// Consider a circle of radius 1

/// centered on the origin.<br></br>

/// A ray comes in from the axis, makes

/// an angle at the origin (measured counter-clockwise from that axis), and

/// departs from the origin.<br></br>

/// The coordinate of the outgoing

/// ray’s intersection with the unit circle is the sine of that angle.<br></br>

/// It

/// ranges from -1 for to +1 for The

/// function has zeroes where the angle is a multiple of .

/// Sines of angles between and are negative.<br></br>

///

/// The numerous properties of the sine and related functions are included

/// in any standard trigonometry text.

/// </summary>

/// <param name="x">

/// Angle, in radians ( rad equals 360 degrees).

/// </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>

/// The sine of each element of x.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray sin(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("sin", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Cosine element-wise.<br></br>

///

/// Notes

///

/// If out is provided, the function writes the result into it,

/// and returns a reference to out.<br></br>

/// (See Examples)

///

/// References

///

/// M.<br></br>

/// Abramowitz and I.<br></br>

/// A.<br></br>

/// Stegun, Handbook of Mathematical Functions.<br></br>

///

/// New York, NY: Dover, 1972.

/// </summary>

/// <param name="x">

/// Input array in radians.

/// </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>

/// The corresponding cosine values.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray cos(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("cos", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Compute tangent element-wise.<br></br>

///

/// Equivalent to np.sin(x)/np.cos(x) element-wise.<br></br>

///

/// Notes

///

/// If out is provided, the function writes the result into it,

/// and returns a reference to out.<br></br>

/// (See Examples)

///

/// References

///

/// M.<br></br>

/// Abramowitz and I.<br></br>

/// A.<br></br>

/// Stegun, Handbook of Mathematical Functions.<br></br>

///

/// New York, NY: Dover, 1972.

/// </summary>

/// <param name="x">

/// Input array.

/// </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>

/// The corresponding tangent values.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray tan(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("tan", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Inverse sine, element-wise.<br></br>

///

/// Notes

///

/// arcsin is a multivalued function: for each x there are infinitely

/// many numbers z such that . The convention is to

/// return the angle z whose real part lies in [-pi/2, pi/2].<br></br>

///

/// For real-valued input data types, arcsin always returns real output.<br></br>

///

/// For each value that cannot be expressed as a real number or infinity,

/// it yields nan and sets the invalid floating point error flag.<br></br>

///

/// For complex-valued input, arcsin is a complex analytic function that

/// has, by convention, the branch cuts [-inf, -1] and [1, inf] and is

/// continuous from above on the former and from below on the latter.<br></br>

///

/// The inverse sine is also known as asin or sin^{-1}.

///

/// References

///

/// Abramowitz, M.<br></br>

/// and Stegun, I.<br></br>

/// A., Handbook of Mathematical Functions,

/// 10th printing, New York: Dover, 1964, pp.<br></br>

/// 79ff.<br></br>

///

/// http://www.math.sfu.ca/~cbm/aands/

/// </summary>

/// <param name="x">

/// y-coordinate on the unit circle.

/// </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>

/// The inverse sine of each element in x, in radians and in the

/// closed interval [-pi/2, pi/2].<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray arcsin(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("arcsin", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Trigonometric inverse cosine, element-wise.<br></br>

///

/// The inverse of cos so that, if y = cos(x), then x = arccos(y).<br></br>

///

/// Notes

///

/// arccos is a multivalued function: for each x there are infinitely

/// many numbers z such that cos(z) = x.<br></br>

/// The convention is to return

/// the angle z whose real part lies in [0, pi].<br></br>

///

/// For real-valued input data types, arccos always returns real output.<br></br>

///

/// For each value that cannot be expressed as a real number or infinity,

/// it yields nan and sets the invalid floating point error flag.<br></br>

///

/// For complex-valued input, arccos is a complex analytic function that

/// has branch cuts [-inf, -1] and [1, inf] and is continuous from

/// above on the former and from below on the latter.<br></br>

///

/// The inverse cos is also known as acos or cos^-1.

///

/// References

///

/// M.<br></br>

/// Abramowitz and I.A.<br></br>

/// Stegun, “Handbook of Mathematical Functions”,

/// 10th printing, 1964, pp.<br></br>

/// 79. http://www.math.sfu.ca/~cbm/aands/

/// </summary>

/// <param name="x">

/// x-coordinate on the unit circle.<br></br>

///

/// For real arguments, the domain is [-1, 1].

/// </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>

/// The angle of the ray intersecting the unit circle at the given

/// x-coordinate in radians [0, pi].<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray arccos(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("arccos", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Trigonometric inverse tangent, element-wise.<br></br>

///

/// The inverse of tan, so that if y = tan(x) then x = arctan(y).<br></br>

///

/// Notes

///

/// arctan is a multi-valued function: for each x there are infinitely

/// many numbers z such that tan(z) = x.<br></br>

/// The convention is to return

/// the angle z whose real part lies in [-pi/2, pi/2].<br></br>

///

/// For real-valued input data types, arctan always returns real output.<br></br>

///

/// For each value that cannot be expressed as a real number or infinity,

/// it yields nan and sets the invalid floating point error flag.<br></br>

///

/// For complex-valued input, arctan is a complex analytic function that

/// has [1j, infj] and [-1j, -infj] as branch cuts, and is continuous

/// from the left on the former and from the right on the latter.<br></br>

///

/// The inverse tangent is also known as atan or tan^{-1}.

///

/// References

///

/// Abramowitz, M.<br></br>

/// and Stegun, I.<br></br>

/// A., Handbook of Mathematical Functions,

/// 10th printing, New York: Dover, 1964, pp.<br></br>

/// 79.

/// http://www.math.sfu.ca/~cbm/aands/

/// </summary>

/// <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>

/// Out has the same shape as x.<br></br>

/// Its real part is in

/// [-pi/2, pi/2] (arctan(+/-inf) returns +/-pi/2).<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray arctan(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("arctan", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Given the “legs” of a right triangle, return its hypotenuse.<br></br>

///

/// Equivalent to sqrt(x1**2 + x2**2), element-wise.<br></br>

/// If x1 or

/// x2 is scalar_like (i.e., unambiguously cast-able to a scalar type),

/// it is broadcast for use with each element of the other argument.<br></br>

///

/// (See Examples)

/// </summary>

/// <param name="x2">

/// Leg of the triangle(s).

/// </param>

/// <param name="x1">

/// Leg of the triangle(s).

/// </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>

/// The hypotenuse of the triangle(s).<br></br>

///

/// This is a scalar if both x1 and x2 are scalars.

/// </returns>

public NDarray hypot(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("hypot", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Element-wise arc tangent of x1/x2 choosing the quadrant correctly.<br></br>

///

/// The quadrant (i.e., branch) is chosen so that arctan2(x1, x2) is

/// the signed angle in radians between the ray ending at the origin and

/// passing through the point (1,0), and the ray ending at the origin and

/// passing through the point (x2, x1).<br></br>

/// (Note the role reversal: the

/// “y-coordinate” is the first function parameter, the “x-coordinate”

/// is the second.) By IEEE convention, this function is defined for

/// x2 = +/-0 and for either or both of x1 and x2 = +/-inf (see

/// Notes for specific values).<br></br>

///

/// This function is not defined for complex-valued arguments; for the

/// so-called argument of complex values, use angle.<br></br>

///

/// Notes

///

/// arctan2 is identical to the atan2 function of the underlying

/// C library.<br></br>

/// The following special values are defined in the C

/// standard: [1]

///

/// Note that +0 and -0 are distinct floating point numbers, as are +inf

/// and -inf.<br></br>

///

/// References

/// </summary>

/// <param name="x1">

/// y-coordinates.

/// </param>

/// <param name="x2">

/// x-coordinates.<br></br>

/// x2 must be broadcastable to match the shape of

/// x1 or vice versa.

/// </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>

/// Array of angles in radians, in the range [-pi, pi].<br></br>

///

/// This is a scalar if both x1 and x2 are scalars.

/// </returns>

public NDarray arctan2(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

x1,

x2,

});

var kwargs=new PyDict();

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

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

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Convert angles from radians to degrees.

/// </summary>

/// <param name="x">

/// Input array in radians.

/// </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>

/// The corresponding degree values; if out was supplied this is a

/// reference to it.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray degrees(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("degrees", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Convert angles from degrees to radians.

/// </summary>

/// <param name="x">

/// Input array in degrees.

/// </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>

/// The corresponding radian values.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray radians(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("radians", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Unwrap by changing deltas between values to 2*pi complement.<br></br>

///

/// Unwrap radian phase p by changing absolute jumps greater than

/// discont to their 2*pi complement along the given axis.<br></br>

///

/// Notes

///

/// If the discontinuity in p is smaller than pi, but larger than

/// discont, no unwrapping is done because taking the 2*pi complement

/// would only make the discontinuity larger.

/// </summary>

/// <param name="p">

/// Input array.

/// </param>

/// <param name="discont">

/// Maximum discontinuity between values, default is pi.

/// </param>

/// <param name="axis">

/// Axis along which unwrap will operate, default is the last axis.

/// </param>

/// <returns>

/// Output array.

/// </returns>

public NDarray unwrap(NDarray p, float? discont = 3.141592653589793f, int? axis = -1)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

p,

});

var kwargs=new PyDict();

if (discont!=3.141592653589793f) kwargs["discont"]=ToPython(discont);

if (axis!=-1) kwargs["axis"]=ToPython(axis);

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Convert angles from degrees to radians.<br></br>

///

/// Notes

///

/// deg2rad(x) is x * pi / 180.

/// </summary>

/// <param name="x">

/// Angles in degrees.

/// </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>

/// The corresponding angle in radians.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray deg2rad(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("deg2rad", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Convert angles from radians to degrees.<br></br>

///

/// Notes

///

/// rad2deg(x) is 180 * x / pi.

/// </summary>

/// <param name="x">

/// Angle in radians.

/// </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>

/// The corresponding angle in degrees.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray rad2deg(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("rad2deg", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Hyperbolic sine, element-wise.<br></br>

///

/// Equivalent to 1/2 * (np.exp(x) - np.exp(-x)) or

/// -1j * np.sin(1j*x).<br></br>

///

/// Notes

///

/// If out is provided, the function writes the result into it,

/// and returns a reference to out.<br></br>

/// (See Examples)

///

/// References

///

/// M.<br></br>

/// Abramowitz and I.<br></br>

/// A.<br></br>

/// Stegun, Handbook of Mathematical Functions.<br></br>

///

/// New York, NY: Dover, 1972, pg.<br></br>

/// 83.

/// </summary>

/// <param name="x">

/// Input array.

/// </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>

/// The corresponding hyperbolic sine values.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray sinh(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("sinh", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Hyperbolic cosine, element-wise.<br></br>

///

/// Equivalent to 1/2 * (np.exp(x) + np.exp(-x)) and np.cos(1j*x).

/// </summary>

/// <param name="x">

/// Input array.

/// </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 of same shape as x.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray cosh(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("cosh", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Compute hyperbolic tangent element-wise.<br></br>

///

/// Equivalent to np.sinh(x)/np.cosh(x) or -1j * np.tan(1j*x).<br></br>

///

/// Notes

///

/// If out is provided, the function writes the result into it,

/// and returns a reference to out.<br></br>

/// (See Examples)

///

/// References

/// </summary>

/// <param name="x">

/// Input array.

/// </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>

/// The corresponding hyperbolic tangent values.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray tanh(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("tanh", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Inverse hyperbolic sine element-wise.<br></br>

///

/// Notes

///

/// arcsinh is a multivalued function: for each x there are infinitely

/// many numbers z such that sinh(z) = x.<br></br>

/// The convention is to return the

/// z whose imaginary part lies in [-pi/2, pi/2].<br></br>

///

/// For real-valued input data types, arcsinh always returns real output.<br></br>

///

/// For each value that cannot be expressed as a real number or infinity, it

/// returns nan and sets the invalid floating point error flag.<br></br>

///

/// For complex-valued input, arccos is a complex analytical function that

/// has branch cuts [1j, infj] and [-1j, -infj] and is continuous from

/// the right on the former and from the left on the latter.<br></br>

///

/// The inverse hyperbolic sine is also known as asinh or sinh^-1.

///

/// References

/// </summary>

/// <param name="x">

/// Input array.

/// </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>

/// Array of the same shape as x.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray arcsinh(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("arcsinh", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Inverse hyperbolic cosine, element-wise.<br></br>

///

/// Notes

///

/// arccosh is a multivalued function: for each x there are infinitely

/// many numbers z such that cosh(z) = x.<br></br>

/// The convention is to return the

/// z whose imaginary part lies in [-pi, pi] and the real part in

/// [0, inf].<br></br>

///

/// For real-valued input data types, arccosh always returns real output.<br></br>

///

/// For each value that cannot be expressed as a real number or infinity, it

/// yields nan and sets the invalid floating point error flag.<br></br>

///

/// For complex-valued input, arccosh is a complex analytical function that

/// has a branch cut [-inf, 1] and is continuous from above on it.<br></br>

///

/// References

/// </summary>

/// <param name="x">

/// Input array.

/// </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>

/// Array of the same shape as x.<br></br>

///

/// This is a scalar if x is a scalar.

/// </returns>

public NDarray arccosh(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("arccosh", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Inverse hyperbolic tangent element-wise.<br></br>

///

/// Notes

///

/// arctanh is a multivalued function: for each x there are infinitely

/// many numbers z such that tanh(z) = x.<br></br>

/// The convention is to return

/// the z whose imaginary part lies in [-pi/2, pi/2].<br></br>

///

/// For real-valued input data types, arctanh always returns real output.<br></br>

///

/// For each value that cannot be expressed as a real number or infinity,

/// it yields nan and sets the invalid floating point error flag.<br></br>

///

/// For complex-valued input, arctanh is a complex analytical function

/// that has branch cuts [-1, -inf] and [1, inf] and is continuous from

/// above on the former and from below on the latter.<br></br>

///

/// The inverse hyperbolic tangent is also known as atanh or tanh^-1.

///