From 0df0a9f8df27b95d52a7afd7ba9fe96018e74c9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 11:09:53 +0800 Subject: [PATCH 01/13] math4 --- math4/_demo/go.mod | 10 ++ math4/_demo/go.sum | 2 + math4/_demo/main.go | 29 ++++ math4/go.mod | 5 + math4/llpkg.cfg | 16 +++ math4/llpyg.cfg | 123 ++++++++++++++++ math4/math.go | 280 +++++++++++++++++++++++++++++++++++++ math4/math_autogen_link.go | 5 + 8 files changed, 470 insertions(+) create mode 100644 math4/_demo/go.mod create mode 100644 math4/_demo/go.sum create mode 100644 math4/_demo/main.go create mode 100644 math4/go.mod create mode 100644 math4/llpkg.cfg create mode 100644 math4/llpyg.cfg create mode 100644 math4/math.go create mode 100644 math4/math_autogen_link.go diff --git a/math4/_demo/go.mod b/math4/_demo/go.mod new file mode 100644 index 00000000..46f5f92f --- /dev/null +++ b/math4/_demo/go.mod @@ -0,0 +1,10 @@ +module test_math3 + +go 1.24.5 + +replace github.com/goplus/llpkg/math => ../ + +require ( + github.com/goplus/lib v0.2.0 + github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 +) diff --git a/math4/_demo/go.sum b/math4/_demo/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/math4/_demo/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math4/_demo/main.go b/math4/_demo/main.go new file mode 100644 index 00000000..023355a1 --- /dev/null +++ b/math4/_demo/main.go @@ -0,0 +1,29 @@ +package main + +import ( + "github.com/goplus/lib/py" + "github.com/goplus/lib/py/std" + "github.com/goplus/llpkg/math" +) + +func main() { + // 初始化 Python + py.Initialize() + defer py.Finalize() + + // 测试 math.Sqrt + result1 := math.Sqrt(py.Float(4.0)) + std.Print(py.Str("sqrt(4) = "), result1) + + // 测试 math.Cos + result2 := math.Cos(py.Float(0.0)) + std.Print(py.Str("cos(0) = "), result2) + + // 测试 math.Pow + result3 := math.Pow(py.Float(2.0), py.Float(3.0)) + std.Print(py.Str("2^3 = "), result3) + + // 测试 math.Sin + result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 + std.Print(py.Str("sin(1.57) = "), result4) +} diff --git a/math4/go.mod b/math4/go.mod new file mode 100644 index 00000000..7d6e6402 --- /dev/null +++ b/math4/go.mod @@ -0,0 +1,5 @@ +module github.com/goplus/llpkg/math + +go 1.23 + +require github.com/goplus/lib v0.2.0 diff --git a/math4/llpkg.cfg b/math4/llpkg.cfg new file mode 100644 index 00000000..dd565d41 --- /dev/null +++ b/math4/llpkg.cfg @@ -0,0 +1,16 @@ +{ + "type": "python", + "upstream": { + "installer": { + "name": "pip", + "config": { + "python_version": "3.12", + "index_url": "https://pypi.org/simple/" + } + }, + "package": { + "name": "math", + "version": "builtin" + } + } +} \ No newline at end of file diff --git a/math4/llpyg.cfg b/math4/llpyg.cfg new file mode 100644 index 00000000..94275e92 --- /dev/null +++ b/math4/llpyg.cfg @@ -0,0 +1,123 @@ +{ + "name": "math", + "module": "math", + "python": true, + "symMap": { + "abs": "Abs", + "acos": "Acos", + "acosh": "Acosh", + "all": "All", + "any": "Any", + "asin": "Asin", + "asinh": "Asinh", + "atan": "Atan", + "atan2": "Atan2", + "atanh": "Atanh", + "bin": "Bin", + "bool": "Bool", + "cbrt": "Cbrt", + "ceil": "Ceil", + "chr": "Chr", + "comb": "Comb", + "copysign": "Copysign", + "cos": "Cos", + "cosh": "Cosh", + "degrees": "Degrees", + "dict": "Dict", + "dir": "Dir", + "dist": "Dist", + "enumerate": "Enumerate", + "erf": "Erf", + "erfc": "Erfc", + "exp": "Exp", + "exp2": "Exp2", + "expm1": "Expm1", + "fabs": "Fabs", + "factorial": "Factorial", + "filter": "Filter", + "float": "Float", + "floor": "Floor", + "fmod": "Fmod", + "format": "Format", + "frexp": "Frexp", + "frozenset": "FrozenSet", + "fsum": "Fsum", + "gamma": "Gamma", + "gcd": "Gcd", + "getattr": "GetAttr", + "hasattr": "HasAttr", + "hash": "Hash", + "help": "Help", + "hex": "Hex", + "id": "ID", + "input": "Input", + "int": "Int", + "isinstance": "IsInstance", + "issubclass": "IsSubclass", + "iter": "Iter", + "len": "Len", + "list": "List", + "locals": "Locals", + "log10": "Log10", + "log2": "Log2", + "map": "Map", + "max": "Max", + "min": "Min", + "modf": "Modf", + "next": "Next", + "nextafter": "Nextafter", + "oct": "Oct", + "open": "Open", + "ord": "Ord", + "perm": "Perm", + "pow": "Pow", + "print": "Print", + "prod": "Prod", + "radians": "Radians", + "range": "Range", + "remainder": "Remainder", + "repr": "Repr", + "reversed": "Reversed", + "round": "Round", + "set": "Set", + "setattr": "SetAttr", + "sin": "Sin", + "sinh": "Sinh", + "sorted": "Sorted", + "sqrt": "Sqrt", + "str": "Str", + "sum": "Sum", + "sumprod": "Sumprod", + "tan": "Tan", + "tanh": "Tanh", + "trunc": "Trunc", + "tuple": "Tuple", + "type": "Type", + "ulp": "Ulp", + "vars": "Vars", + "zip": "Zip" + }, + "deps": [ + "py" + ], + "include": [ + "math" + ], + "exclude": [ + "__builtins__", + "__cached__", + "__doc__", + "__file__", + "__loader__", + "__name__", + "__package__", + "__spec__" + ], + "constants": { + "e": "E", + "inf": "Inf", + "nan": "NaN", + "pi": "Pi", + "tau": "Tau" + } +} \ No newline at end of file diff --git a/math4/math.go b/math4/math.go new file mode 100644 index 00000000..e497df6e --- /dev/null +++ b/math4/math.go @@ -0,0 +1,280 @@ +package math + +import ( + "github.com/goplus/lib/py" + _ "unsafe" +) + +const LLGoPackage = "py.math" +// Return the arc cosine (measured in radians) of x. +// +// The result is between 0 and pi. +// +//go:linkname Acos py.acos +func Acos(x *py.Object) *py.Object +// Return the inverse hyperbolic cosine of x. +// +//go:linkname Acosh py.acosh +func Acosh(x *py.Object) *py.Object +// Return the arc sine (measured in radians) of x. +// +// The result is between -pi/2 and pi/2. +// +//go:linkname Asin py.asin +func Asin(x *py.Object) *py.Object +// Return the inverse hyperbolic sine of x. +// +//go:linkname Asinh py.asinh +func Asinh(x *py.Object) *py.Object +// Return the arc tangent (measured in radians) of x. +// +// The result is between -pi/2 and pi/2. +// +//go:linkname Atan py.atan +func Atan(x *py.Object) *py.Object +// Return the arc tangent (measured in radians) of y/x. +// +// Unlike atan(y/x), the signs of both x and y are considered. +// +//go:linkname Atan2 py.atan2 +func Atan2(y *py.Object, x *py.Object) *py.Object +// Return the inverse hyperbolic tangent of x. +// +//go:linkname Atanh py.atanh +func Atanh(x *py.Object) *py.Object +// Return the cube root of x. +// +//go:linkname Cbrt py.cbrt +func Cbrt(x *py.Object) *py.Object +// Return the ceiling of x as an Integral. +// +// This is the smallest integer >= x. +// +//go:linkname Ceil py.ceil +func Ceil(x *py.Object) *py.Object +// Return a float with the magnitude (absolute value) of x but the sign of y. +// +// On platforms that support signed zeros, copysign(1.0, -0.0) +// returns -1.0. +// +// +//go:linkname Copysign py.copysign +func Copysign(x *py.Object, y *py.Object) *py.Object +// Return the cosine of x (measured in radians). +// +//go:linkname Cos py.cos +func Cos(x *py.Object) *py.Object +// Return the hyperbolic cosine of x. +// +//go:linkname Cosh py.cosh +func Cosh(x *py.Object) *py.Object +// Convert angle x from radians to degrees. +// +//go:linkname Degrees py.degrees +func Degrees(x *py.Object) *py.Object +// Return the Euclidean distance between two points p and q. +// +// The points should be specified as sequences (or iterables) of +// coordinates. Both inputs must have the same dimension. +// +// Roughly equivalent to: +// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) +// +//go:linkname Dist py.dist +func Dist(p *py.Object, q *py.Object) *py.Object +// Error function at x. +// +//go:linkname Erf py.erf +func Erf(x *py.Object) *py.Object +// Complementary error function at x. +// +//go:linkname Erfc py.erfc +func Erfc(x *py.Object) *py.Object +// Return e raised to the power of x. +// +//go:linkname Exp py.exp +func Exp(x *py.Object) *py.Object +// Return 2 raised to the power of x. +// +//go:linkname Exp2 py.exp2 +func Exp2(x *py.Object) *py.Object +// Return exp(x)-1. +// +// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. +// +//go:linkname Expm1 py.expm1 +func Expm1(x *py.Object) *py.Object +// Return the absolute value of the float x. +// +//go:linkname Fabs py.fabs +func Fabs(x *py.Object) *py.Object +// Find n!. +// +// Raise a ValueError if x is negative or non-integral. +// +//go:linkname Factorial py.factorial +func Factorial(n *py.Object) *py.Object +// Return the floor of x as an Integral. +// +// This is the largest integer <= x. +// +//go:linkname Floor py.floor +func Floor(x *py.Object) *py.Object +// Return fmod(x, y), according to platform C. +// +// x % y may differ. +// +//go:linkname Fmod py.fmod +func Fmod(x *py.Object, y *py.Object) *py.Object +// Return the mantissa and exponent of x, as pair (m, e). +// +// m is a float and e is an int, such that x = m * 2.**e. +// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. +// +//go:linkname Frexp py.frexp +func Frexp(x *py.Object) *py.Object +// Return an accurate floating-point sum of values in the iterable seq. +// +// Assumes IEEE-754 floating-point arithmetic. +// +//go:linkname Fsum py.fsum +func Fsum(seq *py.Object) *py.Object +// Gamma function at x. +// +//go:linkname Gamma py.gamma +func Gamma(x *py.Object) *py.Object +// Greatest Common Divisor. +// +//go:linkname Gcd py.gcd +func Gcd(__llgo_va_list ...interface{}) *py.Object +// Return the integer part of the square root of the input. +// +//go:linkname Isqrt py.isqrt +func Isqrt(n *py.Object) *py.Object +// Least Common Multiple. +// +//go:linkname Lcm py.lcm +func Lcm(__llgo_va_list ...interface{}) *py.Object +// Return x * (2**i). +// +// This is essentially the inverse of frexp(). +// +//go:linkname Ldexp py.ldexp +func Ldexp(x *py.Object, i *py.Object) *py.Object +// Natural logarithm of absolute value of Gamma function at x. +// +//go:linkname Lgamma py.lgamma +func Lgamma(x *py.Object) *py.Object +// Return the base 2 logarithm of x. +// +//go:linkname Log2 py.log2 +func Log2(x *py.Object) *py.Object +// Return the fractional and integer parts of x. +// +// Both results carry the sign of x and are floats. +// +//go:linkname Modf py.modf +func Modf(x *py.Object) *py.Object +// Return x**y (x to the power of y). +// +//go:linkname Pow py.pow +func Pow(x *py.Object, y *py.Object) *py.Object +// Convert angle x from degrees to radians. +// +//go:linkname Radians py.radians +func Radians(x *py.Object) *py.Object +// Difference between x and the closest integer multiple of y. +// +// Return x - n*y where n*y is the closest integer multiple of y. +// In the case where x is exactly halfway between two multiples of +// y, the nearest even value of n is used. The result is always exact. +// +//go:linkname Remainder py.remainder +func Remainder(x *py.Object, y *py.Object) *py.Object +// Return the sine of x (measured in radians). +// +//go:linkname Sin py.sin +func Sin(x *py.Object) *py.Object +// Return the hyperbolic sine of x. +// +//go:linkname Sinh py.sinh +func Sinh(x *py.Object) *py.Object +// Return the square root of x. +// +//go:linkname Sqrt py.sqrt +func Sqrt(x *py.Object) *py.Object +// Return the tangent of x (measured in radians). +// +//go:linkname Tan py.tan +func Tan(x *py.Object) *py.Object +// Return the hyperbolic tangent of x. +// +//go:linkname Tanh py.tanh +func Tanh(x *py.Object) *py.Object +// Return the sum of products of values from two iterables p and q. +// +// Roughly equivalent to: +// +// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) +// +// For float and mixed int/float inputs, the intermediate products +// and sums are computed with extended precision. +// +//go:linkname Sumprod py.sumprod +func Sumprod(p *py.Object, q *py.Object) *py.Object +// Truncates the Real x to the nearest Integral toward 0. +// +// Uses the __trunc__ magic method. +// +//go:linkname Trunc py.trunc +func Trunc(x *py.Object) *py.Object +// Calculate the product of all the elements in the input iterable. +// +// The default start value for the product is 1. +// +// When the iterable is empty, return the start value. This function is +// intended specifically for use with numeric values and may reject +// non-numeric types. +// +//go:linkname Prod py.prod +func Prod(iterable *py.Object) *py.Object +// Number of ways to choose k items from n items without repetition and with order. +// +// Evaluates to n! / (n - k)! when k <= n and evaluates +// to zero when k > n. +// +// If k is not specified or is None, then k defaults to n +// and the function returns n!. +// +// Raises TypeError if either of the arguments are not integers. +// Raises ValueError if either of the arguments are negative. +// +//go:linkname Perm py.perm +func Perm(n *py.Object, k *py.Object) *py.Object +// Number of ways to choose k items from n items without repetition and without order. +// +// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates +// to zero when k > n. +// +// Also called the binomial coefficient because it is equivalent +// to the coefficient of k-th term in polynomial expansion of the +// expression (1 + x)**n. +// +// Raises TypeError if either of the arguments are not integers. +// Raises ValueError if either of the arguments are negative. +// +//go:linkname Comb py.comb +func Comb(n *py.Object, k *py.Object) *py.Object +// Return the floating-point value the given number of steps after x towards y. +// +// If steps is not specified or is None, it defaults to 1. +// +// Raises a TypeError, if x or y is not a double, or if steps is not an integer. +// Raises ValueError if steps is negative. +// +//go:linkname Nextafter py.nextafter +func Nextafter(x *py.Object, y *py.Object) *py.Object +// Return the value of the least significant bit of the float x. +// +//go:linkname Ulp py.ulp +func Ulp(x *py.Object) *py.Object diff --git a/math4/math_autogen_link.go b/math4/math_autogen_link.go new file mode 100644 index 00000000..1f657e14 --- /dev/null +++ b/math4/math_autogen_link.go @@ -0,0 +1,5 @@ +package math + +import _ "github.com/goplus/lib/py" + +// LLGoPackage is defined in the main binding file From 0511864d410baaa4246901146615fcfcb48dde68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 12:01:53 +0800 Subject: [PATCH 02/13] math3 --- .DS_Store | Bin 0 -> 6148 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..59f99ee8aa6f5f1d7326b2a03473eb0fbe623fa7 GIT binary patch literal 6148 zcmeH~O-{ow5QU#hs}>Mamu!%7f=a*z($X#}0SkHo`hyB6G|(1=SY^*0xB};61#iX{ zBx$=v2+c_LOPn{h^C^jA0Iu^mIRu&j8Z4sK9ad{Xu1i^oN@&@mI_=}ApQPhal8#oq z)?fsTz~3Vv?`{nvyx<1+$iKhxNocdQJ~edeKhERan=a1x73Ua3%rV8H=yV5boVQpY z#jNCfEjjB*ILi^1^rlEk?vD-bXWTKbbZ3?6M)!j5WwCGN@Rs9H$0_9IcHm&ZsT+I4O>*T=RX^$@D>qEpb&I z*$LacyUHg(>6UsGs(BwzE&d4sd9E0ZU9VOf0V7}pz6r?pAz~4YgJxd!)4@u&0Msg* zHFzw)1CkR3je}-hd4=J8D%GdDu*Gmbo$XQZ#X&Q#J{>M>K3o{tg&m61(b<2bcDUH9 z)keSw6bWqk)26Kdz0LdoVv?O10VD9Q2)Jr@(CzS+!rHoWbF$V(ESD@2;>)~h3ahXj g>wzrA`z#u~7RdoM4w`vo3&VZ{6oXYp;8zKJ0mS8~00000 literal 0 HcmV?d00001 From dcbc62d40e61fac74a09bbdf63f680b259d5e888 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 13:44:45 +0800 Subject: [PATCH 03/13] ver1 --- .github/workflows/verification.yml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/workflows/verification.yml b/.github/workflows/verification.yml index 6ce255da..cef9e496 100644 --- a/.github/workflows/verification.yml +++ b/.github/workflows/verification.yml @@ -82,12 +82,13 @@ jobs: run: | sudo apt install -y python3 python3-pip python3 -m pip install --upgrade pip - python3 -m pip install conan pydump pysigfetch + python3 -m pip install conan pydump + go install github.com/goplus/hdq/chore/pysigfetch@v0.8.1 - name: Pre setup Python and Conan if: startsWith(matrix.os, 'macos') run: | - python3 -m pip install --upgrade pip --break-system-packages - python3 -m pip install conan pydump pysigfetch --break-system-packages + python3 -m pip install conan pydump --break-system-packages + go install github.com/goplus/hdq/chore/pysigfetch@v0.8.1 - name: Set up Conan run: | conan profile detect From 899aff5a30a5d10601792d39fb3d840f466ff7d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 15:00:06 +0800 Subject: [PATCH 04/13] math6 --- math6/_demo/go.mod | 10 ++ math6/_demo/go.sum | 2 + math6/_demo/main.go | 29 ++++ math6/go.mod | 5 + math6/llpkg.cfg | 16 +++ math6/llpyg.cfg | 123 ++++++++++++++++ math6/math.go | 280 +++++++++++++++++++++++++++++++++++++ math6/math_autogen_link.go | 5 + 8 files changed, 470 insertions(+) create mode 100644 math6/_demo/go.mod create mode 100644 math6/_demo/go.sum create mode 100644 math6/_demo/main.go create mode 100644 math6/go.mod create mode 100644 math6/llpkg.cfg create mode 100644 math6/llpyg.cfg create mode 100644 math6/math.go create mode 100644 math6/math_autogen_link.go diff --git a/math6/_demo/go.mod b/math6/_demo/go.mod new file mode 100644 index 00000000..46f5f92f --- /dev/null +++ b/math6/_demo/go.mod @@ -0,0 +1,10 @@ +module test_math3 + +go 1.24.5 + +replace github.com/goplus/llpkg/math => ../ + +require ( + github.com/goplus/lib v0.2.0 + github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 +) diff --git a/math6/_demo/go.sum b/math6/_demo/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/math6/_demo/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math6/_demo/main.go b/math6/_demo/main.go new file mode 100644 index 00000000..023355a1 --- /dev/null +++ b/math6/_demo/main.go @@ -0,0 +1,29 @@ +package main + +import ( + "github.com/goplus/lib/py" + "github.com/goplus/lib/py/std" + "github.com/goplus/llpkg/math" +) + +func main() { + // 初始化 Python + py.Initialize() + defer py.Finalize() + + // 测试 math.Sqrt + result1 := math.Sqrt(py.Float(4.0)) + std.Print(py.Str("sqrt(4) = "), result1) + + // 测试 math.Cos + result2 := math.Cos(py.Float(0.0)) + std.Print(py.Str("cos(0) = "), result2) + + // 测试 math.Pow + result3 := math.Pow(py.Float(2.0), py.Float(3.0)) + std.Print(py.Str("2^3 = "), result3) + + // 测试 math.Sin + result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 + std.Print(py.Str("sin(1.57) = "), result4) +} diff --git a/math6/go.mod b/math6/go.mod new file mode 100644 index 00000000..7d6e6402 --- /dev/null +++ b/math6/go.mod @@ -0,0 +1,5 @@ +module github.com/goplus/llpkg/math + +go 1.23 + +require github.com/goplus/lib v0.2.0 diff --git a/math6/llpkg.cfg b/math6/llpkg.cfg new file mode 100644 index 00000000..dd565d41 --- /dev/null +++ b/math6/llpkg.cfg @@ -0,0 +1,16 @@ +{ + "type": "python", + "upstream": { + "installer": { + "name": "pip", + "config": { + "python_version": "3.12", + "index_url": "https://pypi.org/simple/" + } + }, + "package": { + "name": "math", + "version": "builtin" + } + } +} \ No newline at end of file diff --git a/math6/llpyg.cfg b/math6/llpyg.cfg new file mode 100644 index 00000000..94275e92 --- /dev/null +++ b/math6/llpyg.cfg @@ -0,0 +1,123 @@ +{ + "name": "math", + "module": "math", + "python": true, + "symMap": { + "abs": "Abs", + "acos": "Acos", + "acosh": "Acosh", + "all": "All", + "any": "Any", + "asin": "Asin", + "asinh": "Asinh", + "atan": "Atan", + "atan2": "Atan2", + "atanh": "Atanh", + "bin": "Bin", + "bool": "Bool", + "cbrt": "Cbrt", + "ceil": "Ceil", + "chr": "Chr", + "comb": "Comb", + "copysign": "Copysign", + "cos": "Cos", + "cosh": "Cosh", + "degrees": "Degrees", + "dict": "Dict", + "dir": "Dir", + "dist": "Dist", + "enumerate": "Enumerate", + "erf": "Erf", + "erfc": "Erfc", + "exp": "Exp", + "exp2": "Exp2", + "expm1": "Expm1", + "fabs": "Fabs", + "factorial": "Factorial", + "filter": "Filter", + "float": "Float", + "floor": "Floor", + "fmod": "Fmod", + "format": "Format", + "frexp": "Frexp", + "frozenset": "FrozenSet", + "fsum": "Fsum", + "gamma": "Gamma", + "gcd": "Gcd", + "getattr": "GetAttr", + "hasattr": "HasAttr", + "hash": "Hash", + "help": "Help", + "hex": "Hex", + "id": "ID", + "input": "Input", + "int": "Int", + "isinstance": "IsInstance", + "issubclass": "IsSubclass", + "iter": "Iter", + "len": "Len", + "list": "List", + "locals": "Locals", + "log10": "Log10", + "log2": "Log2", + "map": "Map", + "max": "Max", + "min": "Min", + "modf": "Modf", + "next": "Next", + "nextafter": "Nextafter", + "oct": "Oct", + "open": "Open", + "ord": "Ord", + "perm": "Perm", + "pow": "Pow", + "print": "Print", + "prod": "Prod", + "radians": "Radians", + "range": "Range", + "remainder": "Remainder", + "repr": "Repr", + "reversed": "Reversed", + "round": "Round", + "set": "Set", + "setattr": "SetAttr", + "sin": "Sin", + "sinh": "Sinh", + "sorted": "Sorted", + "sqrt": "Sqrt", + "str": "Str", + "sum": "Sum", + "sumprod": "Sumprod", + "tan": "Tan", + "tanh": "Tanh", + "trunc": "Trunc", + "tuple": "Tuple", + "type": "Type", + "ulp": "Ulp", + "vars": "Vars", + "zip": "Zip" + }, + "deps": [ + "py" + ], + "include": [ + "math" + ], + "exclude": [ + "__builtins__", + "__cached__", + "__doc__", + "__file__", + "__loader__", + "__name__", + "__package__", + "__spec__" + ], + "constants": { + "e": "E", + "inf": "Inf", + "nan": "NaN", + "pi": "Pi", + "tau": "Tau" + } +} \ No newline at end of file diff --git a/math6/math.go b/math6/math.go new file mode 100644 index 00000000..e497df6e --- /dev/null +++ b/math6/math.go @@ -0,0 +1,280 @@ +package math + +import ( + "github.com/goplus/lib/py" + _ "unsafe" +) + +const LLGoPackage = "py.math" +// Return the arc cosine (measured in radians) of x. +// +// The result is between 0 and pi. +// +//go:linkname Acos py.acos +func Acos(x *py.Object) *py.Object +// Return the inverse hyperbolic cosine of x. +// +//go:linkname Acosh py.acosh +func Acosh(x *py.Object) *py.Object +// Return the arc sine (measured in radians) of x. +// +// The result is between -pi/2 and pi/2. +// +//go:linkname Asin py.asin +func Asin(x *py.Object) *py.Object +// Return the inverse hyperbolic sine of x. +// +//go:linkname Asinh py.asinh +func Asinh(x *py.Object) *py.Object +// Return the arc tangent (measured in radians) of x. +// +// The result is between -pi/2 and pi/2. +// +//go:linkname Atan py.atan +func Atan(x *py.Object) *py.Object +// Return the arc tangent (measured in radians) of y/x. +// +// Unlike atan(y/x), the signs of both x and y are considered. +// +//go:linkname Atan2 py.atan2 +func Atan2(y *py.Object, x *py.Object) *py.Object +// Return the inverse hyperbolic tangent of x. +// +//go:linkname Atanh py.atanh +func Atanh(x *py.Object) *py.Object +// Return the cube root of x. +// +//go:linkname Cbrt py.cbrt +func Cbrt(x *py.Object) *py.Object +// Return the ceiling of x as an Integral. +// +// This is the smallest integer >= x. +// +//go:linkname Ceil py.ceil +func Ceil(x *py.Object) *py.Object +// Return a float with the magnitude (absolute value) of x but the sign of y. +// +// On platforms that support signed zeros, copysign(1.0, -0.0) +// returns -1.0. +// +// +//go:linkname Copysign py.copysign +func Copysign(x *py.Object, y *py.Object) *py.Object +// Return the cosine of x (measured in radians). +// +//go:linkname Cos py.cos +func Cos(x *py.Object) *py.Object +// Return the hyperbolic cosine of x. +// +//go:linkname Cosh py.cosh +func Cosh(x *py.Object) *py.Object +// Convert angle x from radians to degrees. +// +//go:linkname Degrees py.degrees +func Degrees(x *py.Object) *py.Object +// Return the Euclidean distance between two points p and q. +// +// The points should be specified as sequences (or iterables) of +// coordinates. Both inputs must have the same dimension. +// +// Roughly equivalent to: +// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) +// +//go:linkname Dist py.dist +func Dist(p *py.Object, q *py.Object) *py.Object +// Error function at x. +// +//go:linkname Erf py.erf +func Erf(x *py.Object) *py.Object +// Complementary error function at x. +// +//go:linkname Erfc py.erfc +func Erfc(x *py.Object) *py.Object +// Return e raised to the power of x. +// +//go:linkname Exp py.exp +func Exp(x *py.Object) *py.Object +// Return 2 raised to the power of x. +// +//go:linkname Exp2 py.exp2 +func Exp2(x *py.Object) *py.Object +// Return exp(x)-1. +// +// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. +// +//go:linkname Expm1 py.expm1 +func Expm1(x *py.Object) *py.Object +// Return the absolute value of the float x. +// +//go:linkname Fabs py.fabs +func Fabs(x *py.Object) *py.Object +// Find n!. +// +// Raise a ValueError if x is negative or non-integral. +// +//go:linkname Factorial py.factorial +func Factorial(n *py.Object) *py.Object +// Return the floor of x as an Integral. +// +// This is the largest integer <= x. +// +//go:linkname Floor py.floor +func Floor(x *py.Object) *py.Object +// Return fmod(x, y), according to platform C. +// +// x % y may differ. +// +//go:linkname Fmod py.fmod +func Fmod(x *py.Object, y *py.Object) *py.Object +// Return the mantissa and exponent of x, as pair (m, e). +// +// m is a float and e is an int, such that x = m * 2.**e. +// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. +// +//go:linkname Frexp py.frexp +func Frexp(x *py.Object) *py.Object +// Return an accurate floating-point sum of values in the iterable seq. +// +// Assumes IEEE-754 floating-point arithmetic. +// +//go:linkname Fsum py.fsum +func Fsum(seq *py.Object) *py.Object +// Gamma function at x. +// +//go:linkname Gamma py.gamma +func Gamma(x *py.Object) *py.Object +// Greatest Common Divisor. +// +//go:linkname Gcd py.gcd +func Gcd(__llgo_va_list ...interface{}) *py.Object +// Return the integer part of the square root of the input. +// +//go:linkname Isqrt py.isqrt +func Isqrt(n *py.Object) *py.Object +// Least Common Multiple. +// +//go:linkname Lcm py.lcm +func Lcm(__llgo_va_list ...interface{}) *py.Object +// Return x * (2**i). +// +// This is essentially the inverse of frexp(). +// +//go:linkname Ldexp py.ldexp +func Ldexp(x *py.Object, i *py.Object) *py.Object +// Natural logarithm of absolute value of Gamma function at x. +// +//go:linkname Lgamma py.lgamma +func Lgamma(x *py.Object) *py.Object +// Return the base 2 logarithm of x. +// +//go:linkname Log2 py.log2 +func Log2(x *py.Object) *py.Object +// Return the fractional and integer parts of x. +// +// Both results carry the sign of x and are floats. +// +//go:linkname Modf py.modf +func Modf(x *py.Object) *py.Object +// Return x**y (x to the power of y). +// +//go:linkname Pow py.pow +func Pow(x *py.Object, y *py.Object) *py.Object +// Convert angle x from degrees to radians. +// +//go:linkname Radians py.radians +func Radians(x *py.Object) *py.Object +// Difference between x and the closest integer multiple of y. +// +// Return x - n*y where n*y is the closest integer multiple of y. +// In the case where x is exactly halfway between two multiples of +// y, the nearest even value of n is used. The result is always exact. +// +//go:linkname Remainder py.remainder +func Remainder(x *py.Object, y *py.Object) *py.Object +// Return the sine of x (measured in radians). +// +//go:linkname Sin py.sin +func Sin(x *py.Object) *py.Object +// Return the hyperbolic sine of x. +// +//go:linkname Sinh py.sinh +func Sinh(x *py.Object) *py.Object +// Return the square root of x. +// +//go:linkname Sqrt py.sqrt +func Sqrt(x *py.Object) *py.Object +// Return the tangent of x (measured in radians). +// +//go:linkname Tan py.tan +func Tan(x *py.Object) *py.Object +// Return the hyperbolic tangent of x. +// +//go:linkname Tanh py.tanh +func Tanh(x *py.Object) *py.Object +// Return the sum of products of values from two iterables p and q. +// +// Roughly equivalent to: +// +// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) +// +// For float and mixed int/float inputs, the intermediate products +// and sums are computed with extended precision. +// +//go:linkname Sumprod py.sumprod +func Sumprod(p *py.Object, q *py.Object) *py.Object +// Truncates the Real x to the nearest Integral toward 0. +// +// Uses the __trunc__ magic method. +// +//go:linkname Trunc py.trunc +func Trunc(x *py.Object) *py.Object +// Calculate the product of all the elements in the input iterable. +// +// The default start value for the product is 1. +// +// When the iterable is empty, return the start value. This function is +// intended specifically for use with numeric values and may reject +// non-numeric types. +// +//go:linkname Prod py.prod +func Prod(iterable *py.Object) *py.Object +// Number of ways to choose k items from n items without repetition and with order. +// +// Evaluates to n! / (n - k)! when k <= n and evaluates +// to zero when k > n. +// +// If k is not specified or is None, then k defaults to n +// and the function returns n!. +// +// Raises TypeError if either of the arguments are not integers. +// Raises ValueError if either of the arguments are negative. +// +//go:linkname Perm py.perm +func Perm(n *py.Object, k *py.Object) *py.Object +// Number of ways to choose k items from n items without repetition and without order. +// +// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates +// to zero when k > n. +// +// Also called the binomial coefficient because it is equivalent +// to the coefficient of k-th term in polynomial expansion of the +// expression (1 + x)**n. +// +// Raises TypeError if either of the arguments are not integers. +// Raises ValueError if either of the arguments are negative. +// +//go:linkname Comb py.comb +func Comb(n *py.Object, k *py.Object) *py.Object +// Return the floating-point value the given number of steps after x towards y. +// +// If steps is not specified or is None, it defaults to 1. +// +// Raises a TypeError, if x or y is not a double, or if steps is not an integer. +// Raises ValueError if steps is negative. +// +//go:linkname Nextafter py.nextafter +func Nextafter(x *py.Object, y *py.Object) *py.Object +// Return the value of the least significant bit of the float x. +// +//go:linkname Ulp py.ulp +func Ulp(x *py.Object) *py.Object diff --git a/math6/math_autogen_link.go b/math6/math_autogen_link.go new file mode 100644 index 00000000..1f657e14 --- /dev/null +++ b/math6/math_autogen_link.go @@ -0,0 +1,5 @@ +package math + +import _ "github.com/goplus/lib/py" + +// LLGoPackage is defined in the main binding file From 63691ecdf894365b84e64455397209231b3342bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 15:55:31 +0800 Subject: [PATCH 05/13] 11 --- .github/workflows/verification.yml | 8 +- math3/_demo/go.mod | 10 -- math3/_demo/go.sum | 2 - math3/_demo/main.go | 29 ---- math3/go.mod | 5 - math3/go.sum | 2 - math3/llpkg.cfg | 16 -- math3/llpyg.cfg | 123 ------------- math3/math.go | 270 ----------------------------- math3/math_autogen_link.go | 5 - 10 files changed, 1 insertion(+), 469 deletions(-) delete mode 100644 math3/_demo/go.mod delete mode 100644 math3/_demo/go.sum delete mode 100644 math3/_demo/main.go delete mode 100644 math3/go.mod delete mode 100644 math3/go.sum delete mode 100644 math3/llpkg.cfg delete mode 100644 math3/llpyg.cfg delete mode 100644 math3/math.go delete mode 100644 math3/math_autogen_link.go diff --git a/.github/workflows/verification.yml b/.github/workflows/verification.yml index cef9e496..ee1d4f6c 100644 --- a/.github/workflows/verification.yml +++ b/.github/workflows/verification.yml @@ -43,12 +43,6 @@ jobs: repository: 'goplus/llcppg' path: .llcppg ref: ${{matrix.llcppg}} - - name: Check out LLPyg - uses: actions/checkout@v4 - with: - repository: 'goplus/llgo' - path: .llpyg - ref: ${{matrix.llgo}} - name: Set up Go uses: actions/setup-go@v4 with: @@ -139,4 +133,4 @@ jobs: - name: Run demotest process env: LLPKG_PATH: ${{ env.LLPKG_PATH }} - run: llpkgstore demotest \ No newline at end of file + run: llpkgstore demotest diff --git a/math3/_demo/go.mod b/math3/_demo/go.mod deleted file mode 100644 index 46f5f92f..00000000 --- a/math3/_demo/go.mod +++ /dev/null @@ -1,10 +0,0 @@ -module test_math3 - -go 1.24.5 - -replace github.com/goplus/llpkg/math => ../ - -require ( - github.com/goplus/lib v0.2.0 - github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 -) diff --git a/math3/_demo/go.sum b/math3/_demo/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/math3/_demo/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math3/_demo/main.go b/math3/_demo/main.go deleted file mode 100644 index 023355a1..00000000 --- a/math3/_demo/main.go +++ /dev/null @@ -1,29 +0,0 @@ -package main - -import ( - "github.com/goplus/lib/py" - "github.com/goplus/lib/py/std" - "github.com/goplus/llpkg/math" -) - -func main() { - // 初始化 Python - py.Initialize() - defer py.Finalize() - - // 测试 math.Sqrt - result1 := math.Sqrt(py.Float(4.0)) - std.Print(py.Str("sqrt(4) = "), result1) - - // 测试 math.Cos - result2 := math.Cos(py.Float(0.0)) - std.Print(py.Str("cos(0) = "), result2) - - // 测试 math.Pow - result3 := math.Pow(py.Float(2.0), py.Float(3.0)) - std.Print(py.Str("2^3 = "), result3) - - // 测试 math.Sin - result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 - std.Print(py.Str("sin(1.57) = "), result4) -} diff --git a/math3/go.mod b/math3/go.mod deleted file mode 100644 index 7d6e6402..00000000 --- a/math3/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/goplus/llpkg/math - -go 1.23 - -require github.com/goplus/lib v0.2.0 diff --git a/math3/go.sum b/math3/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/math3/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math3/llpkg.cfg b/math3/llpkg.cfg deleted file mode 100644 index dd565d41..00000000 --- a/math3/llpkg.cfg +++ /dev/null @@ -1,16 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "python_version": "3.12", - "index_url": "https://pypi.org/simple/" - } - }, - "package": { - "name": "math", - "version": "builtin" - } - } -} \ No newline at end of file diff --git a/math3/llpyg.cfg b/math3/llpyg.cfg deleted file mode 100644 index 94275e92..00000000 --- a/math3/llpyg.cfg +++ /dev/null @@ -1,123 +0,0 @@ -{ - "name": "math", - "module": "math", - "python": true, - "symMap": { - "abs": "Abs", - "acos": "Acos", - "acosh": "Acosh", - "all": "All", - "any": "Any", - "asin": "Asin", - "asinh": "Asinh", - "atan": "Atan", - "atan2": "Atan2", - "atanh": "Atanh", - "bin": "Bin", - "bool": "Bool", - "cbrt": "Cbrt", - "ceil": "Ceil", - "chr": "Chr", - "comb": "Comb", - "copysign": "Copysign", - "cos": "Cos", - "cosh": "Cosh", - "degrees": "Degrees", - "dict": "Dict", - "dir": "Dir", - "dist": "Dist", - "enumerate": "Enumerate", - "erf": "Erf", - "erfc": "Erfc", - "exp": "Exp", - "exp2": "Exp2", - "expm1": "Expm1", - "fabs": "Fabs", - "factorial": "Factorial", - "filter": "Filter", - "float": "Float", - "floor": "Floor", - "fmod": "Fmod", - "format": "Format", - "frexp": "Frexp", - "frozenset": "FrozenSet", - "fsum": "Fsum", - "gamma": "Gamma", - "gcd": "Gcd", - "getattr": "GetAttr", - "hasattr": "HasAttr", - "hash": "Hash", - "help": "Help", - "hex": "Hex", - "id": "ID", - "input": "Input", - "int": "Int", - "isinstance": "IsInstance", - "issubclass": "IsSubclass", - "iter": "Iter", - "len": "Len", - "list": "List", - "locals": "Locals", - "log10": "Log10", - "log2": "Log2", - "map": "Map", - "max": "Max", - "min": "Min", - "modf": "Modf", - "next": "Next", - "nextafter": "Nextafter", - "oct": "Oct", - "open": "Open", - "ord": "Ord", - "perm": "Perm", - "pow": "Pow", - "print": "Print", - "prod": "Prod", - "radians": "Radians", - "range": "Range", - "remainder": "Remainder", - "repr": "Repr", - "reversed": "Reversed", - "round": "Round", - "set": "Set", - "setattr": "SetAttr", - "sin": "Sin", - "sinh": "Sinh", - "sorted": "Sorted", - "sqrt": "Sqrt", - "str": "Str", - "sum": "Sum", - "sumprod": "Sumprod", - "tan": "Tan", - "tanh": "Tanh", - "trunc": "Trunc", - "tuple": "Tuple", - "type": "Type", - "ulp": "Ulp", - "vars": "Vars", - "zip": "Zip" - }, - "deps": [ - "py" - ], - "include": [ - "math" - ], - "exclude": [ - "__builtins__", - "__cached__", - "__doc__", - "__file__", - "__loader__", - "__name__", - "__package__", - "__spec__" - ], - "constants": { - "e": "E", - "inf": "Inf", - "nan": "NaN", - "pi": "Pi", - "tau": "Tau" - } -} \ No newline at end of file diff --git a/math3/math.go b/math3/math.go deleted file mode 100644 index 4c3f0c8e..00000000 --- a/math3/math.go +++ /dev/null @@ -1,270 +0,0 @@ -package math - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -//const LLGoPackage = "py.math" -// Return the arc cosine (measured in radians) of x. -// -// The result is between 0 and pi. -// -//go:linkname Acos py.acos -func Acos(x *py.Object) *py.Object -// Return the inverse hyperbolic cosine of x. -// -//go:linkname Acosh py.acosh -func Acosh(x *py.Object) *py.Object -// Return the arc sine (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Asin py.asin -func Asin(x *py.Object) *py.Object -// Return the inverse hyperbolic sine of x. -// -//go:linkname Asinh py.asinh -func Asinh(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Atan py.atan -func Atan(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of y/x. -// -// Unlike atan(y/x), the signs of both x and y are considered. -// -//go:linkname Atan2 py.atan2 -func Atan2(y *py.Object, x *py.Object) *py.Object -// Return the inverse hyperbolic tangent of x. -// -//go:linkname Atanh py.atanh -func Atanh(x *py.Object) *py.Object -// Return the cube root of x. -// -//go:linkname Cbrt py.cbrt -func Cbrt(x *py.Object) *py.Object -// Return the ceiling of x as an Integral. -// -// This is the smallest integer >= x. -// -//go:linkname Ceil py.ceil -func Ceil(x *py.Object) *py.Object -// Return a float with the magnitude (absolute value) of x but the sign of y. -// -// On platforms that support signed zeros, copysign(1.0, -0.0) -// returns -1.0. -// -// -//go:linkname Copysign py.copysign -func Copysign(x *py.Object, y *py.Object) *py.Object -// Return the cosine of x (measured in radians). -// -//go:linkname Cos py.cos -func Cos(x *py.Object) *py.Object -// Return the hyperbolic cosine of x. -// -//go:linkname Cosh py.cosh -func Cosh(x *py.Object) *py.Object -// Convert angle x from radians to degrees. -// -//go:linkname Degrees py.degrees -func Degrees(x *py.Object) *py.Object -// Return the Euclidean distance between two points p and q. -// -// The points should be specified as sequences (or iterables) of -// coordinates. Both inputs must have the same dimension. -// -// Roughly equivalent to: -// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) -// -//go:linkname Dist py.dist -func Dist(p *py.Object, q *py.Object) *py.Object -// Error function at x. -// -//go:linkname Erf py.erf -func Erf(x *py.Object) *py.Object -// Complementary error function at x. -// -//go:linkname Erfc py.erfc -func Erfc(x *py.Object) *py.Object -// Return e raised to the power of x. -// -//go:linkname Exp py.exp -func Exp(x *py.Object) *py.Object -// Return 2 raised to the power of x. -// -//go:linkname Exp2 py.exp2 -func Exp2(x *py.Object) *py.Object -// Return exp(x)-1. -// -// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. -// -//go:linkname Expm1 py.expm1 -func Expm1(x *py.Object) *py.Object -// Return the absolute value of the float x. -// -//go:linkname Fabs py.fabs -func Fabs(x *py.Object) *py.Object -// Find n!. -// -// Raise a ValueError if x is negative or non-integral. -// -//go:linkname Factorial py.factorial -func Factorial(n *py.Object) *py.Object -// Return the floor of x as an Integral. -// -// This is the largest integer <= x. -// -//go:linkname Floor py.floor -func Floor(x *py.Object) *py.Object -// Return fmod(x, y), according to platform C. -// -// x % y may differ. -// -//go:linkname Fmod py.fmod -func Fmod(x *py.Object, y *py.Object) *py.Object -// Return the mantissa and exponent of x, as pair (m, e). -// -// m is a float and e is an int, such that x = m * 2.**e. -// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. -// -//go:linkname Frexp py.frexp -func Frexp(x *py.Object) *py.Object -// Return an accurate floating-point sum of values in the iterable seq. -// -// Assumes IEEE-754 floating-point arithmetic. -// -//go:linkname Fsum py.fsum -func Fsum(seq *py.Object) *py.Object -// Gamma function at x. -// -//go:linkname Gamma py.gamma -func Gamma(x *py.Object) *py.Object -// Greatest Common Divisor. -// -//go:linkname Gcd py.gcd -func Gcd(__llgo_va_list ...interface{}) *py.Object -// Return the integer part of the square root of the input. -// -//go:linkname Isqrt py.isqrt -func Isqrt(n *py.Object) *py.Object -// Least Common Multiple. -// -//go:linkname Lcm py.lcm -func Lcm(__llgo_va_list ...interface{}) *py.Object -// Return x * (2**i). -// -// This is essentially the inverse of frexp(). -// -//go:linkname Ldexp py.ldexp -func Ldexp(x *py.Object, i *py.Object) *py.Object -// Natural logarithm of absolute value of Gamma function at x. -// -//go:linkname Lgamma py.lgamma -func Lgamma(x *py.Object) *py.Object -// Return x**y (x to the power of y). -// -//go:linkname Pow py.pow -func Pow(x *py.Object, y *py.Object) *py.Object -// Convert angle x from degrees to radians. -// -//go:linkname Radians py.radians -func Radians(x *py.Object) *py.Object -// Difference between x and the closest integer multiple of y. -// -// Return x - n*y where n*y is the closest integer multiple of y. -// In the case where x is exactly halfway between two multiples of -// y, the nearest even value of n is used. The result is always exact. -// -//go:linkname Remainder py.remainder -func Remainder(x *py.Object, y *py.Object) *py.Object -// Return the sine of x (measured in radians). -// -//go:linkname Sin py.sin -func Sin(x *py.Object) *py.Object -// Return the hyperbolic sine of x. -// -//go:linkname Sinh py.sinh -func Sinh(x *py.Object) *py.Object -// Return the square root of x. -// -//go:linkname Sqrt py.sqrt -func Sqrt(x *py.Object) *py.Object -// Return the tangent of x (measured in radians). -// -//go:linkname Tan py.tan -func Tan(x *py.Object) *py.Object -// Return the hyperbolic tangent of x. -// -//go:linkname Tanh py.tanh -func Tanh(x *py.Object) *py.Object -// Return the sum of products of values from two iterables p and q. -// -// Roughly equivalent to: -// -// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) -// -// For float and mixed int/float inputs, the intermediate products -// and sums are computed with extended precision. -// -//go:linkname Sumprod py.sumprod -func Sumprod(p *py.Object, q *py.Object) *py.Object -// Truncates the Real x to the nearest Integral toward 0. -// -// Uses the __trunc__ magic method. -// -//go:linkname Trunc py.trunc -func Trunc(x *py.Object) *py.Object -// Calculate the product of all the elements in the input iterable. -// -// The default start value for the product is 1. -// -// When the iterable is empty, return the start value. This function is -// intended specifically for use with numeric values and may reject -// non-numeric types. -// -//go:linkname Prod py.prod -func Prod(iterable *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and with order. -// -// Evaluates to n! / (n - k)! when k <= n and evaluates -// to zero when k > n. -// -// If k is not specified or is None, then k defaults to n -// and the function returns n!. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Perm py.perm -func Perm(n *py.Object, k *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and without order. -// -// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates -// to zero when k > n. -// -// Also called the binomial coefficient because it is equivalent -// to the coefficient of k-th term in polynomial expansion of the -// expression (1 + x)**n. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Comb py.comb -func Comb(n *py.Object, k *py.Object) *py.Object -// Return the floating-point value the given number of steps after x towards y. -// -// If steps is not specified or is None, it defaults to 1. -// -// Raises a TypeError, if x or y is not a double, or if steps is not an integer. -// Raises ValueError if steps is negative. -// -//go:linkname Nextafter py.nextafter -func Nextafter(x *py.Object, y *py.Object) *py.Object -// Return the value of the least significant bit of the float x. -// -//go:linkname Ulp py.ulp -func Ulp(x *py.Object) *py.Object diff --git a/math3/math_autogen_link.go b/math3/math_autogen_link.go deleted file mode 100644 index 767d62b8..00000000 --- a/math3/math_autogen_link.go +++ /dev/null @@ -1,5 +0,0 @@ -package math - -import _ "github.com/goplus/lib/py" - -const LLGoPackage string = "py.math" \ No newline at end of file From 3b37d35027c1e35a9c593ad230ecc52674ab4728 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 15:58:24 +0800 Subject: [PATCH 06/13] math5 --- math5/_demo/go.mod | 10 ++ math5/_demo/go.sum | 2 + math5/_demo/main.go | 29 ++++ math5/go.mod | 5 + math5/llpkg.cfg | 16 +++ math5/llpyg.cfg | 123 ++++++++++++++++ math5/math.go | 280 +++++++++++++++++++++++++++++++++++++ math5/math_autogen_link.go | 5 + 8 files changed, 470 insertions(+) create mode 100644 math5/_demo/go.mod create mode 100644 math5/_demo/go.sum create mode 100644 math5/_demo/main.go create mode 100644 math5/go.mod create mode 100644 math5/llpkg.cfg create mode 100644 math5/llpyg.cfg create mode 100644 math5/math.go create mode 100644 math5/math_autogen_link.go diff --git a/math5/_demo/go.mod b/math5/_demo/go.mod new file mode 100644 index 00000000..46f5f92f --- /dev/null +++ b/math5/_demo/go.mod @@ -0,0 +1,10 @@ +module test_math3 + +go 1.24.5 + +replace github.com/goplus/llpkg/math => ../ + +require ( + github.com/goplus/lib v0.2.0 + github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 +) diff --git a/math5/_demo/go.sum b/math5/_demo/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/math5/_demo/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math5/_demo/main.go b/math5/_demo/main.go new file mode 100644 index 00000000..023355a1 --- /dev/null +++ b/math5/_demo/main.go @@ -0,0 +1,29 @@ +package main + +import ( + "github.com/goplus/lib/py" + "github.com/goplus/lib/py/std" + "github.com/goplus/llpkg/math" +) + +func main() { + // 初始化 Python + py.Initialize() + defer py.Finalize() + + // 测试 math.Sqrt + result1 := math.Sqrt(py.Float(4.0)) + std.Print(py.Str("sqrt(4) = "), result1) + + // 测试 math.Cos + result2 := math.Cos(py.Float(0.0)) + std.Print(py.Str("cos(0) = "), result2) + + // 测试 math.Pow + result3 := math.Pow(py.Float(2.0), py.Float(3.0)) + std.Print(py.Str("2^3 = "), result3) + + // 测试 math.Sin + result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 + std.Print(py.Str("sin(1.57) = "), result4) +} diff --git a/math5/go.mod b/math5/go.mod new file mode 100644 index 00000000..7d6e6402 --- /dev/null +++ b/math5/go.mod @@ -0,0 +1,5 @@ +module github.com/goplus/llpkg/math + +go 1.23 + +require github.com/goplus/lib v0.2.0 diff --git a/math5/llpkg.cfg b/math5/llpkg.cfg new file mode 100644 index 00000000..dd565d41 --- /dev/null +++ b/math5/llpkg.cfg @@ -0,0 +1,16 @@ +{ + "type": "python", + "upstream": { + "installer": { + "name": "pip", + "config": { + "python_version": "3.12", + "index_url": "https://pypi.org/simple/" + } + }, + "package": { + "name": "math", + "version": "builtin" + } + } +} \ No newline at end of file diff --git a/math5/llpyg.cfg b/math5/llpyg.cfg new file mode 100644 index 00000000..94275e92 --- /dev/null +++ b/math5/llpyg.cfg @@ -0,0 +1,123 @@ +{ + "name": "math", + "module": "math", + "python": true, + "symMap": { + "abs": "Abs", + "acos": "Acos", + "acosh": "Acosh", + "all": "All", + "any": "Any", + "asin": "Asin", + "asinh": "Asinh", + "atan": "Atan", + "atan2": "Atan2", + "atanh": "Atanh", + "bin": "Bin", + "bool": "Bool", + "cbrt": "Cbrt", + "ceil": "Ceil", + "chr": "Chr", + "comb": "Comb", + "copysign": "Copysign", + "cos": "Cos", + "cosh": "Cosh", + "degrees": "Degrees", + "dict": "Dict", + "dir": "Dir", + "dist": "Dist", + "enumerate": "Enumerate", + "erf": "Erf", + "erfc": "Erfc", + "exp": "Exp", + "exp2": "Exp2", + "expm1": "Expm1", + "fabs": "Fabs", + "factorial": "Factorial", + "filter": "Filter", + "float": "Float", + "floor": "Floor", + "fmod": "Fmod", + "format": "Format", + "frexp": "Frexp", + "frozenset": "FrozenSet", + "fsum": "Fsum", + "gamma": "Gamma", + "gcd": "Gcd", + "getattr": "GetAttr", + "hasattr": "HasAttr", + "hash": "Hash", + "help": "Help", + "hex": "Hex", + "id": "ID", + "input": "Input", + "int": "Int", + "isinstance": "IsInstance", + "issubclass": "IsSubclass", + "iter": "Iter", + "len": "Len", + "list": "List", + "locals": "Locals", + "log10": "Log10", + "log2": "Log2", + "map": "Map", + "max": "Max", + "min": "Min", + "modf": "Modf", + "next": "Next", + "nextafter": "Nextafter", + "oct": "Oct", + "open": "Open", + "ord": "Ord", + "perm": "Perm", + "pow": "Pow", + "print": "Print", + "prod": "Prod", + "radians": "Radians", + "range": "Range", + "remainder": "Remainder", + "repr": "Repr", + "reversed": "Reversed", + "round": "Round", + "set": "Set", + "setattr": "SetAttr", + "sin": "Sin", + "sinh": "Sinh", + "sorted": "Sorted", + "sqrt": "Sqrt", + "str": "Str", + "sum": "Sum", + "sumprod": "Sumprod", + "tan": "Tan", + "tanh": "Tanh", + "trunc": "Trunc", + "tuple": "Tuple", + "type": "Type", + "ulp": "Ulp", + "vars": "Vars", + "zip": "Zip" + }, + "deps": [ + "py" + ], + "include": [ + "math" + ], + "exclude": [ + "__builtins__", + "__cached__", + "__doc__", + "__file__", + "__loader__", + "__name__", + "__package__", + "__spec__" + ], + "constants": { + "e": "E", + "inf": "Inf", + "nan": "NaN", + "pi": "Pi", + "tau": "Tau" + } +} \ No newline at end of file diff --git a/math5/math.go b/math5/math.go new file mode 100644 index 00000000..e497df6e --- /dev/null +++ b/math5/math.go @@ -0,0 +1,280 @@ +package math + +import ( + "github.com/goplus/lib/py" + _ "unsafe" +) + +const LLGoPackage = "py.math" +// Return the arc cosine (measured in radians) of x. +// +// The result is between 0 and pi. +// +//go:linkname Acos py.acos +func Acos(x *py.Object) *py.Object +// Return the inverse hyperbolic cosine of x. +// +//go:linkname Acosh py.acosh +func Acosh(x *py.Object) *py.Object +// Return the arc sine (measured in radians) of x. +// +// The result is between -pi/2 and pi/2. +// +//go:linkname Asin py.asin +func Asin(x *py.Object) *py.Object +// Return the inverse hyperbolic sine of x. +// +//go:linkname Asinh py.asinh +func Asinh(x *py.Object) *py.Object +// Return the arc tangent (measured in radians) of x. +// +// The result is between -pi/2 and pi/2. +// +//go:linkname Atan py.atan +func Atan(x *py.Object) *py.Object +// Return the arc tangent (measured in radians) of y/x. +// +// Unlike atan(y/x), the signs of both x and y are considered. +// +//go:linkname Atan2 py.atan2 +func Atan2(y *py.Object, x *py.Object) *py.Object +// Return the inverse hyperbolic tangent of x. +// +//go:linkname Atanh py.atanh +func Atanh(x *py.Object) *py.Object +// Return the cube root of x. +// +//go:linkname Cbrt py.cbrt +func Cbrt(x *py.Object) *py.Object +// Return the ceiling of x as an Integral. +// +// This is the smallest integer >= x. +// +//go:linkname Ceil py.ceil +func Ceil(x *py.Object) *py.Object +// Return a float with the magnitude (absolute value) of x but the sign of y. +// +// On platforms that support signed zeros, copysign(1.0, -0.0) +// returns -1.0. +// +// +//go:linkname Copysign py.copysign +func Copysign(x *py.Object, y *py.Object) *py.Object +// Return the cosine of x (measured in radians). +// +//go:linkname Cos py.cos +func Cos(x *py.Object) *py.Object +// Return the hyperbolic cosine of x. +// +//go:linkname Cosh py.cosh +func Cosh(x *py.Object) *py.Object +// Convert angle x from radians to degrees. +// +//go:linkname Degrees py.degrees +func Degrees(x *py.Object) *py.Object +// Return the Euclidean distance between two points p and q. +// +// The points should be specified as sequences (or iterables) of +// coordinates. Both inputs must have the same dimension. +// +// Roughly equivalent to: +// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) +// +//go:linkname Dist py.dist +func Dist(p *py.Object, q *py.Object) *py.Object +// Error function at x. +// +//go:linkname Erf py.erf +func Erf(x *py.Object) *py.Object +// Complementary error function at x. +// +//go:linkname Erfc py.erfc +func Erfc(x *py.Object) *py.Object +// Return e raised to the power of x. +// +//go:linkname Exp py.exp +func Exp(x *py.Object) *py.Object +// Return 2 raised to the power of x. +// +//go:linkname Exp2 py.exp2 +func Exp2(x *py.Object) *py.Object +// Return exp(x)-1. +// +// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. +// +//go:linkname Expm1 py.expm1 +func Expm1(x *py.Object) *py.Object +// Return the absolute value of the float x. +// +//go:linkname Fabs py.fabs +func Fabs(x *py.Object) *py.Object +// Find n!. +// +// Raise a ValueError if x is negative or non-integral. +// +//go:linkname Factorial py.factorial +func Factorial(n *py.Object) *py.Object +// Return the floor of x as an Integral. +// +// This is the largest integer <= x. +// +//go:linkname Floor py.floor +func Floor(x *py.Object) *py.Object +// Return fmod(x, y), according to platform C. +// +// x % y may differ. +// +//go:linkname Fmod py.fmod +func Fmod(x *py.Object, y *py.Object) *py.Object +// Return the mantissa and exponent of x, as pair (m, e). +// +// m is a float and e is an int, such that x = m * 2.**e. +// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. +// +//go:linkname Frexp py.frexp +func Frexp(x *py.Object) *py.Object +// Return an accurate floating-point sum of values in the iterable seq. +// +// Assumes IEEE-754 floating-point arithmetic. +// +//go:linkname Fsum py.fsum +func Fsum(seq *py.Object) *py.Object +// Gamma function at x. +// +//go:linkname Gamma py.gamma +func Gamma(x *py.Object) *py.Object +// Greatest Common Divisor. +// +//go:linkname Gcd py.gcd +func Gcd(__llgo_va_list ...interface{}) *py.Object +// Return the integer part of the square root of the input. +// +//go:linkname Isqrt py.isqrt +func Isqrt(n *py.Object) *py.Object +// Least Common Multiple. +// +//go:linkname Lcm py.lcm +func Lcm(__llgo_va_list ...interface{}) *py.Object +// Return x * (2**i). +// +// This is essentially the inverse of frexp(). +// +//go:linkname Ldexp py.ldexp +func Ldexp(x *py.Object, i *py.Object) *py.Object +// Natural logarithm of absolute value of Gamma function at x. +// +//go:linkname Lgamma py.lgamma +func Lgamma(x *py.Object) *py.Object +// Return the base 2 logarithm of x. +// +//go:linkname Log2 py.log2 +func Log2(x *py.Object) *py.Object +// Return the fractional and integer parts of x. +// +// Both results carry the sign of x and are floats. +// +//go:linkname Modf py.modf +func Modf(x *py.Object) *py.Object +// Return x**y (x to the power of y). +// +//go:linkname Pow py.pow +func Pow(x *py.Object, y *py.Object) *py.Object +// Convert angle x from degrees to radians. +// +//go:linkname Radians py.radians +func Radians(x *py.Object) *py.Object +// Difference between x and the closest integer multiple of y. +// +// Return x - n*y where n*y is the closest integer multiple of y. +// In the case where x is exactly halfway between two multiples of +// y, the nearest even value of n is used. The result is always exact. +// +//go:linkname Remainder py.remainder +func Remainder(x *py.Object, y *py.Object) *py.Object +// Return the sine of x (measured in radians). +// +//go:linkname Sin py.sin +func Sin(x *py.Object) *py.Object +// Return the hyperbolic sine of x. +// +//go:linkname Sinh py.sinh +func Sinh(x *py.Object) *py.Object +// Return the square root of x. +// +//go:linkname Sqrt py.sqrt +func Sqrt(x *py.Object) *py.Object +// Return the tangent of x (measured in radians). +// +//go:linkname Tan py.tan +func Tan(x *py.Object) *py.Object +// Return the hyperbolic tangent of x. +// +//go:linkname Tanh py.tanh +func Tanh(x *py.Object) *py.Object +// Return the sum of products of values from two iterables p and q. +// +// Roughly equivalent to: +// +// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) +// +// For float and mixed int/float inputs, the intermediate products +// and sums are computed with extended precision. +// +//go:linkname Sumprod py.sumprod +func Sumprod(p *py.Object, q *py.Object) *py.Object +// Truncates the Real x to the nearest Integral toward 0. +// +// Uses the __trunc__ magic method. +// +//go:linkname Trunc py.trunc +func Trunc(x *py.Object) *py.Object +// Calculate the product of all the elements in the input iterable. +// +// The default start value for the product is 1. +// +// When the iterable is empty, return the start value. This function is +// intended specifically for use with numeric values and may reject +// non-numeric types. +// +//go:linkname Prod py.prod +func Prod(iterable *py.Object) *py.Object +// Number of ways to choose k items from n items without repetition and with order. +// +// Evaluates to n! / (n - k)! when k <= n and evaluates +// to zero when k > n. +// +// If k is not specified or is None, then k defaults to n +// and the function returns n!. +// +// Raises TypeError if either of the arguments are not integers. +// Raises ValueError if either of the arguments are negative. +// +//go:linkname Perm py.perm +func Perm(n *py.Object, k *py.Object) *py.Object +// Number of ways to choose k items from n items without repetition and without order. +// +// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates +// to zero when k > n. +// +// Also called the binomial coefficient because it is equivalent +// to the coefficient of k-th term in polynomial expansion of the +// expression (1 + x)**n. +// +// Raises TypeError if either of the arguments are not integers. +// Raises ValueError if either of the arguments are negative. +// +//go:linkname Comb py.comb +func Comb(n *py.Object, k *py.Object) *py.Object +// Return the floating-point value the given number of steps after x towards y. +// +// If steps is not specified or is None, it defaults to 1. +// +// Raises a TypeError, if x or y is not a double, or if steps is not an integer. +// Raises ValueError if steps is negative. +// +//go:linkname Nextafter py.nextafter +func Nextafter(x *py.Object, y *py.Object) *py.Object +// Return the value of the least significant bit of the float x. +// +//go:linkname Ulp py.ulp +func Ulp(x *py.Object) *py.Object diff --git a/math5/math_autogen_link.go b/math5/math_autogen_link.go new file mode 100644 index 00000000..1f657e14 --- /dev/null +++ b/math5/math_autogen_link.go @@ -0,0 +1,5 @@ +package math + +import _ "github.com/goplus/lib/py" + +// LLGoPackage is defined in the main binding file From f1857e5319ffdc4a9b2a04df2179220f802c536b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 16:06:29 +0800 Subject: [PATCH 07/13] math --- math/_demo/go.mod | 10 ++ math/_demo/go.sum | 2 + math/_demo/main.go | 29 ++++ math/go.mod | 5 + math/go.sum | 2 + math/llpkg.cfg | 16 +++ math/llpyg.cfg | 123 +++++++++++++++++ math/math.go | 276 ++++++++++++++++++++++++++++++++++++++ math/math_autogen_link.go | 5 + 9 files changed, 468 insertions(+) create mode 100644 math/_demo/go.mod create mode 100644 math/_demo/go.sum create mode 100644 math/_demo/main.go create mode 100644 math/go.mod create mode 100644 math/go.sum create mode 100644 math/llpkg.cfg create mode 100644 math/llpyg.cfg create mode 100644 math/math.go create mode 100644 math/math_autogen_link.go diff --git a/math/_demo/go.mod b/math/_demo/go.mod new file mode 100644 index 00000000..46f5f92f --- /dev/null +++ b/math/_demo/go.mod @@ -0,0 +1,10 @@ +module test_math3 + +go 1.24.5 + +replace github.com/goplus/llpkg/math => ../ + +require ( + github.com/goplus/lib v0.2.0 + github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 +) diff --git a/math/_demo/go.sum b/math/_demo/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/math/_demo/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math/_demo/main.go b/math/_demo/main.go new file mode 100644 index 00000000..023355a1 --- /dev/null +++ b/math/_demo/main.go @@ -0,0 +1,29 @@ +package main + +import ( + "github.com/goplus/lib/py" + "github.com/goplus/lib/py/std" + "github.com/goplus/llpkg/math" +) + +func main() { + // 初始化 Python + py.Initialize() + defer py.Finalize() + + // 测试 math.Sqrt + result1 := math.Sqrt(py.Float(4.0)) + std.Print(py.Str("sqrt(4) = "), result1) + + // 测试 math.Cos + result2 := math.Cos(py.Float(0.0)) + std.Print(py.Str("cos(0) = "), result2) + + // 测试 math.Pow + result3 := math.Pow(py.Float(2.0), py.Float(3.0)) + std.Print(py.Str("2^3 = "), result3) + + // 测试 math.Sin + result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 + std.Print(py.Str("sin(1.57) = "), result4) +} diff --git a/math/go.mod b/math/go.mod new file mode 100644 index 00000000..7d6e6402 --- /dev/null +++ b/math/go.mod @@ -0,0 +1,5 @@ +module github.com/goplus/llpkg/math + +go 1.23 + +require github.com/goplus/lib v0.2.0 diff --git a/math/go.sum b/math/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/math/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math/llpkg.cfg b/math/llpkg.cfg new file mode 100644 index 00000000..dd565d41 --- /dev/null +++ b/math/llpkg.cfg @@ -0,0 +1,16 @@ +{ + "type": "python", + "upstream": { + "installer": { + "name": "pip", + "config": { + "python_version": "3.12", + "index_url": "https://pypi.org/simple/" + } + }, + "package": { + "name": "math", + "version": "builtin" + } + } +} \ No newline at end of file diff --git a/math/llpyg.cfg b/math/llpyg.cfg new file mode 100644 index 00000000..94275e92 --- /dev/null +++ b/math/llpyg.cfg @@ -0,0 +1,123 @@ +{ + "name": "math", + "module": "math", + "python": true, + "symMap": { + "abs": "Abs", + "acos": "Acos", + "acosh": "Acosh", + "all": "All", + "any": "Any", + "asin": "Asin", + "asinh": "Asinh", + "atan": "Atan", + "atan2": "Atan2", + "atanh": "Atanh", + "bin": "Bin", + "bool": "Bool", + "cbrt": "Cbrt", + "ceil": "Ceil", + "chr": "Chr", + "comb": "Comb", + "copysign": "Copysign", + "cos": "Cos", + "cosh": "Cosh", + "degrees": "Degrees", + "dict": "Dict", + "dir": "Dir", + "dist": "Dist", + "enumerate": "Enumerate", + "erf": "Erf", + "erfc": "Erfc", + "exp": "Exp", + "exp2": "Exp2", + "expm1": "Expm1", + "fabs": "Fabs", + "factorial": "Factorial", + "filter": "Filter", + "float": "Float", + "floor": "Floor", + "fmod": "Fmod", + "format": "Format", + "frexp": "Frexp", + "frozenset": "FrozenSet", + "fsum": "Fsum", + "gamma": "Gamma", + "gcd": "Gcd", + "getattr": "GetAttr", + "hasattr": "HasAttr", + "hash": "Hash", + "help": "Help", + "hex": "Hex", + "id": "ID", + "input": "Input", + "int": "Int", + "isinstance": "IsInstance", + "issubclass": "IsSubclass", + "iter": "Iter", + "len": "Len", + "list": "List", + "locals": "Locals", + "log10": "Log10", + "log2": "Log2", + "map": "Map", + "max": "Max", + "min": "Min", + "modf": "Modf", + "next": "Next", + "nextafter": "Nextafter", + "oct": "Oct", + "open": "Open", + "ord": "Ord", + "perm": "Perm", + "pow": "Pow", + "print": "Print", + "prod": "Prod", + "radians": "Radians", + "range": "Range", + "remainder": "Remainder", + "repr": "Repr", + "reversed": "Reversed", + "round": "Round", + "set": "Set", + "setattr": "SetAttr", + "sin": "Sin", + "sinh": "Sinh", + "sorted": "Sorted", + "sqrt": "Sqrt", + "str": "Str", + "sum": "Sum", + "sumprod": "Sumprod", + "tan": "Tan", + "tanh": "Tanh", + "trunc": "Trunc", + "tuple": "Tuple", + "type": "Type", + "ulp": "Ulp", + "vars": "Vars", + "zip": "Zip" + }, + "deps": [ + "py" + ], + "include": [ + "math" + ], + "exclude": [ + "__builtins__", + "__cached__", + "__doc__", + "__file__", + "__loader__", + "__name__", + "__package__", + "__spec__" + ], + "constants": { + "e": "E", + "inf": "Inf", + "nan": "NaN", + "pi": "Pi", + "tau": "Tau" + } +} \ No newline at end of file diff --git a/math/math.go b/math/math.go new file mode 100644 index 00000000..4d1b43de --- /dev/null +++ b/math/math.go @@ -0,0 +1,276 @@ +package math + +import ( + "github.com/goplus/lib/py" + _ "unsafe" +) + +const LLGoPackage = "py.math" +// Return the arc cosine (measured in radians) of x. +// +// The result is between 0 and pi. +// +//go:linkname Acos py.acos +func Acos(x *py.Object) *py.Object +// Return the inverse hyperbolic cosine of x. +// +//go:linkname Acosh py.acosh +func Acosh(x *py.Object) *py.Object +// Return the arc sine (measured in radians) of x. +// +// The result is between -pi/2 and pi/2. +// +//go:linkname Asin py.asin +func Asin(x *py.Object) *py.Object +// Return the inverse hyperbolic sine of x. +// +//go:linkname Asinh py.asinh +func Asinh(x *py.Object) *py.Object +// Return the arc tangent (measured in radians) of x. +// +// The result is between -pi/2 and pi/2. +// +//go:linkname Atan py.atan +func Atan(x *py.Object) *py.Object +// Return the arc tangent (measured in radians) of y/x. +// +// Unlike atan(y/x), the signs of both x and y are considered. +// +//go:linkname Atan2 py.atan2 +func Atan2(y *py.Object, x *py.Object) *py.Object +// Return the inverse hyperbolic tangent of x. +// +//go:linkname Atanh py.atanh +func Atanh(x *py.Object) *py.Object +// Return the cube root of x. +// +//go:linkname Cbrt py.cbrt +func Cbrt(x *py.Object) *py.Object +// Return the ceiling of x as an Integral. +// +// This is the smallest integer >= x. +// +//go:linkname Ceil py.ceil +func Ceil(x *py.Object) *py.Object +// Return a float with the magnitude (absolute value) of x but the sign of y. +// +// On platforms that support signed zeros, copysign(1.0, -0.0) +// returns -1.0. +// +// +//go:linkname Copysign py.copysign +func Copysign(x *py.Object, y *py.Object) *py.Object +// Return the cosine of x (measured in radians). +// +//go:linkname Cos py.cos +func Cos(x *py.Object) *py.Object +// Return the hyperbolic cosine of x. +// +//go:linkname Cosh py.cosh +func Cosh(x *py.Object) *py.Object +// Convert angle x from radians to degrees. +// +//go:linkname Degrees py.degrees +func Degrees(x *py.Object) *py.Object +// Return the Euclidean distance between two points p and q. +// +// The points should be specified as sequences (or iterables) of +// coordinates. Both inputs must have the same dimension. +// +// Roughly equivalent to: +// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) +// +//go:linkname Dist py.dist +func Dist(p *py.Object, q *py.Object) *py.Object +// Error function at x. +// +//go:linkname Erf py.erf +func Erf(x *py.Object) *py.Object +// Complementary error function at x. +// +//go:linkname Erfc py.erfc +func Erfc(x *py.Object) *py.Object +// Return e raised to the power of x. +// +//go:linkname Exp py.exp +func Exp(x *py.Object) *py.Object +// Return 2 raised to the power of x. +// +//go:linkname Exp2 py.exp2 +func Exp2(x *py.Object) *py.Object +// Return exp(x)-1. +// +// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. +// +//go:linkname Expm1 py.expm1 +func Expm1(x *py.Object) *py.Object +// Return the absolute value of the float x. +// +//go:linkname Fabs py.fabs +func Fabs(x *py.Object) *py.Object +// Find n!. +// +// Raise a ValueError if x is negative or non-integral. +// +//go:linkname Factorial py.factorial +func Factorial(n *py.Object) *py.Object +// Return the floor of x as an Integral. +// +// This is the largest integer <= x. +// +//go:linkname Floor py.floor +func Floor(x *py.Object) *py.Object +// Return fmod(x, y), according to platform C. +// +// x % y may differ. +// +//go:linkname Fmod py.fmod +func Fmod(x *py.Object, y *py.Object) *py.Object +// Return the mantissa and exponent of x, as pair (m, e). +// +// m is a float and e is an int, such that x = m * 2.**e. +// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. +// +//go:linkname Frexp py.frexp +func Frexp(x *py.Object) *py.Object +// Return an accurate floating-point sum of values in the iterable seq. +// +// Assumes IEEE-754 floating-point arithmetic. +// +//go:linkname Fsum py.fsum +func Fsum(seq *py.Object) *py.Object +// Gamma function at x. +// +//go:linkname Gamma py.gamma +func Gamma(x *py.Object) *py.Object +// Greatest Common Divisor. +// +//go:linkname Gcd py.gcd +func Gcd(__llgo_va_list ...interface{}) *py.Object +// Return x * (2**i). +// +// This is essentially the inverse of frexp(). +// +//go:linkname Ldexp py.ldexp +func Ldexp(x *py.Object, i *py.Object) *py.Object +// Natural logarithm of absolute value of Gamma function at x. +// +//go:linkname Lgamma py.lgamma +func Lgamma(x *py.Object) *py.Object +// Return the base 10 logarithm of x. +// +//go:linkname Log10 py.log10 +func Log10(x *py.Object) *py.Object +// Return the base 2 logarithm of x. +// +//go:linkname Log2 py.log2 +func Log2(x *py.Object) *py.Object +// Return the fractional and integer parts of x. +// +// Both results carry the sign of x and are floats. +// +//go:linkname Modf py.modf +func Modf(x *py.Object) *py.Object +// Return x**y (x to the power of y). +// +//go:linkname Pow py.pow +func Pow(x *py.Object, y *py.Object) *py.Object +// Convert angle x from degrees to radians. +// +//go:linkname Radians py.radians +func Radians(x *py.Object) *py.Object +// Difference between x and the closest integer multiple of y. +// +// Return x - n*y where n*y is the closest integer multiple of y. +// In the case where x is exactly halfway between two multiples of +// y, the nearest even value of n is used. The result is always exact. +// +//go:linkname Remainder py.remainder +func Remainder(x *py.Object, y *py.Object) *py.Object +// Return the sine of x (measured in radians). +// +//go:linkname Sin py.sin +func Sin(x *py.Object) *py.Object +// Return the hyperbolic sine of x. +// +//go:linkname Sinh py.sinh +func Sinh(x *py.Object) *py.Object +// Return the square root of x. +// +//go:linkname Sqrt py.sqrt +func Sqrt(x *py.Object) *py.Object +// Return the tangent of x (measured in radians). +// +//go:linkname Tan py.tan +func Tan(x *py.Object) *py.Object +// Return the hyperbolic tangent of x. +// +//go:linkname Tanh py.tanh +func Tanh(x *py.Object) *py.Object +// Return the sum of products of values from two iterables p and q. +// +// Roughly equivalent to: +// +// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) +// +// For float and mixed int/float inputs, the intermediate products +// and sums are computed with extended precision. +// +//go:linkname Sumprod py.sumprod +func Sumprod(p *py.Object, q *py.Object) *py.Object +// Truncates the Real x to the nearest Integral toward 0. +// +// Uses the __trunc__ magic method. +// +//go:linkname Trunc py.trunc +func Trunc(x *py.Object) *py.Object +// Calculate the product of all the elements in the input iterable. +// +// The default start value for the product is 1. +// +// When the iterable is empty, return the start value. This function is +// intended specifically for use with numeric values and may reject +// non-numeric types. +// +//go:linkname Prod py.prod +func Prod(iterable *py.Object) *py.Object +// Number of ways to choose k items from n items without repetition and with order. +// +// Evaluates to n! / (n - k)! when k <= n and evaluates +// to zero when k > n. +// +// If k is not specified or is None, then k defaults to n +// and the function returns n!. +// +// Raises TypeError if either of the arguments are not integers. +// Raises ValueError if either of the arguments are negative. +// +//go:linkname Perm py.perm +func Perm(n *py.Object, k *py.Object) *py.Object +// Number of ways to choose k items from n items without repetition and without order. +// +// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates +// to zero when k > n. +// +// Also called the binomial coefficient because it is equivalent +// to the coefficient of k-th term in polynomial expansion of the +// expression (1 + x)**n. +// +// Raises TypeError if either of the arguments are not integers. +// Raises ValueError if either of the arguments are negative. +// +//go:linkname Comb py.comb +func Comb(n *py.Object, k *py.Object) *py.Object +// Return the floating-point value the given number of steps after x towards y. +// +// If steps is not specified or is None, it defaults to 1. +// +// Raises a TypeError, if x or y is not a double, or if steps is not an integer. +// Raises ValueError if steps is negative. +// +//go:linkname Nextafter py.nextafter +func Nextafter(x *py.Object, y *py.Object) *py.Object +// Return the value of the least significant bit of the float x. +// +//go:linkname Ulp py.ulp +func Ulp(x *py.Object) *py.Object diff --git a/math/math_autogen_link.go b/math/math_autogen_link.go new file mode 100644 index 00000000..1f657e14 --- /dev/null +++ b/math/math_autogen_link.go @@ -0,0 +1,5 @@ +package math + +import _ "github.com/goplus/lib/py" + +// LLGoPackage is defined in the main binding file From 7f3e22cd9742bea2da43e6bbaaf45e7612c72e3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 17:03:42 +0800 Subject: [PATCH 08/13] numpy --- numpy/_demo/go.mod | 10 + numpy/_demo/go.sum | 2 + numpy/_demo/main.go | 11 + numpy/go.mod | 5 + numpy/go.sum | 2 + numpy/llpkg.cfg | 16 + numpy/llpyg.cfg | 155 + numpy/numpy.go | 9589 +++++++++++++++++++++++++++++++++++ numpy/numpy_autogen_link.go | 5 + 9 files changed, 9795 insertions(+) create mode 100644 numpy/_demo/go.mod create mode 100644 numpy/_demo/go.sum create mode 100644 numpy/_demo/main.go create mode 100644 numpy/go.mod create mode 100644 numpy/go.sum create mode 100644 numpy/llpkg.cfg create mode 100644 numpy/llpyg.cfg create mode 100644 numpy/numpy.go create mode 100644 numpy/numpy_autogen_link.go diff --git a/numpy/_demo/go.mod b/numpy/_demo/go.mod new file mode 100644 index 00000000..46f5f92f --- /dev/null +++ b/numpy/_demo/go.mod @@ -0,0 +1,10 @@ +module test_math3 + +go 1.24.5 + +replace github.com/goplus/llpkg/math => ../ + +require ( + github.com/goplus/lib v0.2.0 + github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 +) diff --git a/numpy/_demo/go.sum b/numpy/_demo/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/numpy/_demo/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy/_demo/main.go b/numpy/_demo/main.go new file mode 100644 index 00000000..c34d0173 --- /dev/null +++ b/numpy/_demo/main.go @@ -0,0 +1,11 @@ +package main + +import ( + "github.com/goplus/lib/py" +) + +func main() { + // 初始化 Python + py.Initialize() + defer py.Finalize() +} diff --git a/numpy/go.mod b/numpy/go.mod new file mode 100644 index 00000000..82bc5445 --- /dev/null +++ b/numpy/go.mod @@ -0,0 +1,5 @@ +module github.com/goplus/llpkg/numpy + +go 1.23 + +require github.com/goplus/lib v0.2.0 diff --git a/numpy/go.sum b/numpy/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/numpy/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy/llpkg.cfg b/numpy/llpkg.cfg new file mode 100644 index 00000000..44e6cd3e --- /dev/null +++ b/numpy/llpkg.cfg @@ -0,0 +1,16 @@ +{ + "type": "python", + "upstream": { + "installer": { + "name": "pip", + "config": { + "python_version": "3.12", + "index_url": "https://pypi.org/simple/" + } + }, + "package": { + "name": "numpy", + "version": "1.26.4" + } + } +} \ No newline at end of file diff --git a/numpy/llpyg.cfg b/numpy/llpyg.cfg new file mode 100644 index 00000000..b8888a8d --- /dev/null +++ b/numpy/llpyg.cfg @@ -0,0 +1,155 @@ +{ + "name": "numpy", + "module": "numpy", + "python": true, + "symMap": { + "abs": "Abs", + "absolute": "Absolute", + "add": "Add", + "all": "All", + "any": "Any", + "arange": "Arange", + "arccos": "Arccos", + "arccosh": "Arccosh", + "arcsin": "Arcsin", + "arcsinh": "Arcsinh", + "arctan": "Arctan", + "arctanh": "Arctanh", + "array": "Array", + "average": "Average", + "bin": "Bin", + "bool": "Bool", + "c_": "C", + "ceil": "Ceil", + "chr": "Chr", + "corrcoef": "Corrcoef", + "cos": "Cos", + "cosh": "Cosh", + "cov": "Cov", + "cross": "Cross", + "diag": "Diag", + "dict": "Dict", + "dir": "Dir", + "divide": "Divide", + "dot": "Dot", + "einsum": "Einsum", + "empty": "Empty", + "enumerate": "Enumerate", + "exp": "Exp", + "eye": "Eye", + "fabs": "Fabs", + "fft": "Fft", + "filter": "Filter", + "float": "Float", + "floor": "Floor", + "format": "Format", + "frozenset": "FrozenSet", + "getattr": "GetAttr", + "hasattr": "HasAttr", + "hash": "Hash", + "help": "Help", + "hex": "Hex", + "id": "ID", + "identity": "Identity", + "inner": "Inner", + "input": "Input", + "int": "Int", + "isinstance": "IsInstance", + "issubclass": "IsSubclass", + "iter": "Iter", + "len": "Len", + "linalg": "Linalg", + "linspace": "Linspace", + "list": "List", + "locals": "Locals", + "log": "Log", + "log10": "Log10", + "log2": "Log2", + "logspace": "Logspace", + "map": "Map", + "matmul": "Matmul", + "max": "Max", + "mean": "Mean", + "median": "Median", + "meshgrid": "Meshgrid", + "mgrid": "Mgrid", + "min": "Min", + "mod": "Mod", + "multiply": "Multiply", + "next": "Next", + "oct": "Oct", + "ogrid": "Ogrid", + "ones": "Ones", + "open": "Open", + "ord": "Ord", + "outer": "Outer", + "percentile": "Percentile", + "pow": "Pow", + "power": "Power", + "print": "Print", + "prod": "Prod", + "ptp": "Ptp", + "quantile": "Quantile", + "r_": "R", + "random": "Random", + "range": "Range", + "remainder": "Remainder", + "repr": "Repr", + "reversed": "Reversed", + "rint": "Rint", + "round": "Round", + "set": "Set", + "setattr": "SetAttr", + "sign": "Sign", + "sin": "Sin", + "sinh": "Sinh", + "sorted": "Sorted", + "sqrt": "Sqrt", + "std": "Std", + "str": "Str", + "subtract": "Subtract", + "sum": "Sum", + "tan": "Tan", + "tanh": "Tanh", + "tensordot": "Tensordot", + "tri": "Tri", + "tril": "Tril", + "triu": "Triu", + "trunc": "Trunc", + "tuple": "Tuple", + "type": "Type", + "vander": "Vander", + "var": "Var", + "vars": "Vars", + "zeros": "Zeros", + "zip": "Zip" + }, + "deps": [ + "py" + ], + "include": [ + "numpy" + ], + "exclude": [ + "__builtins__", + "__cached__", + "__doc__", + "__file__", + "__loader__", + "__name__", + "__package__", + "__spec__" + ], + "constants": { + "bool_": "Bool", + "e": "E", + "float32": "Float32", + "float64": "Float64", + "inf": "Inf", + "int32": "Int32", + "int64": "Int64", + "nan": "NaN", + "pi": "Pi", + "uint8": "Uint8" + } +} \ No newline at end of file diff --git a/numpy/numpy.go b/numpy/numpy.go new file mode 100644 index 00000000..a8146d45 --- /dev/null +++ b/numpy/numpy.go @@ -0,0 +1,9589 @@ +package numpy + +import ( + "github.com/goplus/lib/py" + _ "unsafe" +) + +const LLGoPackage = "py.numpy" +// +// Show libraries and system information on which NumPy was built +// and is being used +// +// Parameters +// ---------- +// mode : {`'stdout'`, `'dicts'`}, optional. +// Indicates how to display the config information. +// `'stdout'` prints to console, `'dicts'` returns a dictionary +// of the configuration. +// +// Returns +// ------- +// out : {`dict`, `None`} +// If mode is `'dicts'`, a dict is returned, else None +// +// See Also +// -------- +// get_include : Returns the directory containing NumPy C +// header files. +// +// Notes +// ----- +// 1. The `'stdout'` mode will give more readable +// output if ``pyyaml`` is installed +// +// +// +//go:linkname ShowConfig py.show_config +func ShowConfig(mode *py.Object) *py.Object +// +// Check 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. +// +// Parameters +// ---------- +// a : ndarray +// Input array. +// +// Returns +// ------- +// isfortran : bool +// Returns True if the array is Fortran contiguous but *not* C contiguous. +// +// +// Examples +// -------- +// +// np.array allows to specify whether the array is written in C-contiguous +// order (last index varies the fastest), or FORTRAN-contiguous order in +// memory (first index varies the fastest). +// +// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') +// >>> a +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(a) +// False +// +// >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') +// >>> b +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(b) +// True +// +// +// The transpose of a C-ordered array is a FORTRAN-ordered array. +// +// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') +// >>> a +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(a) +// False +// >>> b = a.T +// >>> b +// array([[1, 4], +// [2, 5], +// [3, 6]]) +// >>> np.isfortran(b) +// True +// +// C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. +// +// >>> np.isfortran(np.array([1, 2], order='F')) +// False +// +// +// +//go:linkname Isfortran py.isfortran +func Isfortran(a *py.Object) *py.Object +// +// Return an array representing the indices of a grid. +// +// Compute an array where the subarrays contain index values 0, 1, ... +// varying only along the corresponding axis. +// +// Parameters +// ---------- +// dimensions : sequence of ints +// The shape of the grid. +// dtype : dtype, optional +// Data type of the result. +// sparse : boolean, optional +// Return a sparse representation of the grid instead of a dense +// representation. Default is False. +// +// .. versionadded:: 1.17 +// +// Returns +// ------- +// grid : one ndarray or tuple of ndarrays +// If sparse is False: +// Returns one array of grid indices, +// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. +// If sparse is True: +// Returns a tuple of arrays, with +// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with +// dimensions[i] in the ith place +// +// See Also +// -------- +// mgrid, ogrid, meshgrid +// +// Notes +// ----- +// The output shape in the dense case is obtained by prepending the number +// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` +// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is +// ``(N, r0, ..., rN-1)``. +// +// The subarrays ``grid[k]`` contains the N-D array of indices along the +// ``k-th`` axis. Explicitly:: +// +// grid[k, i0, i1, ..., iN-1] = ik +// +// Examples +// -------- +// >>> grid = np.indices((2, 3)) +// >>> grid.shape +// (2, 2, 3) +// >>> grid[0] # row indices +// array([[0, 0, 0], +// [1, 1, 1]]) +// >>> grid[1] # column indices +// array([[0, 1, 2], +// [0, 1, 2]]) +// +// The indices can be used as an index into an array. +// +// >>> x = np.arange(20).reshape(5, 4) +// >>> row, col = np.indices((2, 3)) +// >>> x[row, col] +// array([[0, 1, 2], +// [4, 5, 6]]) +// +// Note that it would be more straightforward in the above example to +// extract the required elements directly with ``x[:2, :3]``. +// +// If sparse is set to true, the grid will be returned in a sparse +// representation. +// +// >>> i, j = np.indices((2, 3), sparse=True) +// >>> i.shape +// (2, 1) +// >>> j.shape +// (1, 3) +// >>> i # row indices +// array([[0], +// [1]]) +// >>> j # column indices +// array([[0, 1, 2]]) +// +// +// +//go:linkname Indices py.indices +func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object +// +// Construct an array by executing a function over each coordinate. +// +// The resulting array therefore has a value ``fn(x, y, z)`` at +// coordinate ``(x, y, z)``. +// +// Parameters +// ---------- +// function : callable +// The function is called with N parameters, where N is the rank of +// `shape`. Each parameter represents the coordinates of the array +// varying along a specific axis. For example, if `shape` +// were ``(2, 2)``, then the parameters would be +// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` +// shape : (N,) tuple of ints +// Shape of the output array, which also determines the shape of +// the coordinate arrays passed to `function`. +// dtype : data-type, optional +// Data-type of the coordinate arrays passed to `function`. +// By default, `dtype` is float. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// fromfunction : any +// The result of the call to `function` is passed back directly. +// Therefore the shape of `fromfunction` is completely determined by +// `function`. If `function` returns a scalar value, the shape of +// `fromfunction` would not match the `shape` parameter. +// +// See Also +// -------- +// indices, meshgrid +// +// Notes +// ----- +// Keywords other than `dtype` and `like` are passed to `function`. +// +// Examples +// -------- +// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) +// array([[0., 0.], +// [1., 1.]]) +// +// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) +// array([[0., 1.], +// [0., 1.]]) +// +// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) +// array([[ True, False, False], +// [False, True, False], +// [False, False, True]]) +// +// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) +// array([[0, 1, 2], +// [1, 2, 3], +// [2, 3, 4]]) +// +// +// +//go:linkname Fromfunction py.fromfunction +func Fromfunction(function *py.Object, shape *py.Object) *py.Object +// +// Returns True if the type of `element` is a scalar type. +// +// Parameters +// ---------- +// element : any +// Input argument, can be of any type and shape. +// +// Returns +// ------- +// val : bool +// True if `element` is a scalar type, False if it is not. +// +// See Also +// -------- +// ndim : Get the number of dimensions of an array +// +// Notes +// ----- +// If you need a stricter way to identify a *numerical* scalar, use +// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most +// non-numerical elements such as strings. +// +// In most 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: +// +// +--------------------------------------+---------------+-------------------+ +// | x |``isscalar(x)``|``np.ndim(x) == 0``| +// +======================================+===============+===================+ +// | PEP 3141 numeric objects (including | ``True`` | ``True`` | +// | builtins) | | | +// +--------------------------------------+---------------+-------------------+ +// | builtin string and buffer objects | ``True`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other builtin objects, like | ``False`` | ``True`` | +// | `pathlib.Path`, `Exception`, | | | +// | the result of `re.compile` | | | +// +--------------------------------------+---------------+-------------------+ +// | third-party objects like | ``False`` | ``True`` | +// | `matplotlib.figure.Figure` | | | +// +--------------------------------------+---------------+-------------------+ +// | zero-dimensional numpy arrays | ``False`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other numpy arrays | ``False`` | ``False`` | +// +--------------------------------------+---------------+-------------------+ +// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | +// | objects | | | +// +--------------------------------------+---------------+-------------------+ +// +// Examples +// -------- +// >>> np.isscalar(3.1) +// True +// >>> np.isscalar(np.array(3.1)) +// False +// >>> np.isscalar([3.1]) +// False +// >>> np.isscalar(False) +// True +// >>> np.isscalar('numpy') +// True +// +// NumPy supports PEP 3141 numbers: +// +// >>> from fractions import Fraction +// >>> np.isscalar(Fraction(5, 17)) +// True +// >>> from numbers import Number +// >>> np.isscalar(Number()) +// True +// +// +// +//go:linkname Isscalar py.isscalar +func Isscalar(element *py.Object) *py.Object +// +// Return the binary representation of the input number as a string. +// +// For negative numbers, if width is not given, a minus sign is added to the +// front. If width is given, the two's complement of the number is +// returned, with respect to that width. +// +// In a two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit two's-complement +// system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// num : int +// Only an integer decimal number can be used. +// width : int, optional +// The length of the returned string if `num` is positive, or the length +// of the two's complement if `num` is negative, provided that `width` is +// at least a sufficient number of bits for `num` to be represented in the +// designated form. +// +// If the `width` value is insufficient, it will be ignored, and `num` will +// be returned in binary (`num` > 0) or two's complement (`num` < 0) form +// with its width equal to the minimum number of bits needed to represent +// the number in the designated form. This behavior is deprecated and will +// later raise an error. +// +// .. deprecated:: 1.12.0 +// +// Returns +// ------- +// bin : str +// Binary representation of `num` or two's complement of `num`. +// +// See Also +// -------- +// base_repr: Return a string representation of a number in the given base +// system. +// bin: Python's built-in binary representation generator of an integer. +// +// Notes +// ----- +// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x +// faster. +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// >>> np.binary_repr(3) +// '11' +// >>> np.binary_repr(-3) +// '-11' +// >>> np.binary_repr(3, width=4) +// '0011' +// +// The two's complement is returned when the input number is negative and +// width is specified: +// +// >>> np.binary_repr(-3, width=3) +// '101' +// >>> np.binary_repr(-3, width=5) +// '11101' +// +// +// +//go:linkname BinaryRepr py.binary_repr +func BinaryRepr(num *py.Object, width *py.Object) *py.Object +// +// Return a string representation of a number in the given base system. +// +// Parameters +// ---------- +// number : int +// The value to convert. Positive and negative values are handled. +// base : int, optional +// Convert `number` to the `base` number system. The valid range is 2-36, +// the default value is 2. +// padding : int, optional +// Number of zeros padded on the left. Default is 0 (no padding). +// +// Returns +// ------- +// out : str +// String representation of `number` in `base` system. +// +// See Also +// -------- +// binary_repr : Faster version of `base_repr` for base 2. +// +// Examples +// -------- +// >>> np.base_repr(5) +// '101' +// >>> np.base_repr(6, 5) +// '11' +// >>> np.base_repr(7, base=5, padding=3) +// '00012' +// +// >>> np.base_repr(10, base=16) +// 'A' +// >>> np.base_repr(32, base=16) +// '20' +// +// +// +//go:linkname BaseRepr py.base_repr +func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object +// +// Return a new array of given shape and type, filled with ones. +// +// Parameters +// ---------- +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// dtype : data-type, optional +// The desired data-type for the array, e.g., `numpy.int8`. Default is +// `numpy.float64`. +// order : {'C', 'F'}, optional, default: C +// Whether to store multi-dimensional data in row-major +// (C-style) or column-major (Fortran-style) order in +// memory. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of ones with the given shape, dtype, and order. +// +// See Also +// -------- +// ones_like : Return an array of ones with shape and type of input. +// empty : Return a new uninitialized array. +// zeros : Return a new array setting values to zero. +// full : Return a new array of given shape filled with value. +// +// +// Examples +// -------- +// >>> np.ones(5) +// array([1., 1., 1., 1., 1.]) +// +// >>> np.ones((5,), dtype=int) +// array([1, 1, 1, 1, 1]) +// +// >>> np.ones((2, 1)) +// array([[1.], +// [1.]]) +// +// >>> s = (2,2) +// >>> np.ones(s) +// array([[1., 1.], +// [1., 1.]]) +// +// +// +//go:linkname Ones py.ones +func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// Return the identity array. +// +// The identity array is a square array with ones on +// the main diagonal. +// +// Parameters +// ---------- +// n : int +// Number of rows (and columns) in `n` x `n` output. +// dtype : data-type, optional +// Data-type of the output. Defaults to ``float``. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// `n` x `n` array with its main diagonal set to one, +// and all other elements 0. +// +// Examples +// -------- +// >>> np.identity(3) +// array([[1., 0., 0.], +// [0., 1., 0.], +// [0., 0., 1.]]) +// +// +// +//go:linkname Identity py.identity +func Identity(n *py.Object, dtype *py.Object) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. +// +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: +// +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' +// +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) +// +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) +// +//go:linkname BitwiseNot py.bitwise_not +func BitwiseNot(__llgo_va_list ...interface{}) *py.Object +// +// Return a new array of given shape and type, filled with `fill_value`. +// +// Parameters +// ---------- +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// fill_value : scalar or array_like +// Fill value. +// dtype : data-type, optional +// The desired data-type for the array The default, None, means +// ``np.array(fill_value).dtype``. +// order : {'C', 'F'}, optional +// Whether to store multidimensional data in C- or Fortran-contiguous +// (row- or column-wise) order in memory. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of `fill_value` with the given shape, dtype, and order. +// +// See Also +// -------- +// full_like : Return a new array with shape of input filled with value. +// empty : Return a new uninitialized array. +// ones : Return a new array setting values to one. +// zeros : Return a new array setting values to zero. +// +// Examples +// -------- +// >>> np.full((2, 2), np.inf) +// array([[inf, inf], +// [inf, inf]]) +// >>> np.full((2, 2), 10) +// array([[10, 10], +// [10, 10]]) +// +// >>> np.full((2, 2), [1, 2]) +// array([[1, 2], +// [1, 2]]) +// +// +// +//go:linkname Full py.full +func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object +// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) +// +// Matrix product of two arrays. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays, scalars not allowed. +// out : ndarray, optional +// A location into which the result is stored. If provided, it must have +// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not +// provided or None, a freshly-allocated array is returned. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// .. versionadded:: 1.16 +// Now handles ufunc kwargs +// +// Returns +// ------- +// y : ndarray +// The matrix product of the inputs. +// This is a scalar only when both x1, x2 are 1-d vectors. +// +// Raises +// ------ +// ValueError +// If the last dimension of `x1` is not the same size as +// the second-to-last dimension of `x2`. +// +// If a scalar value is passed in. +// +// See Also +// -------- +// vdot : Complex-conjugating dot product. +// tensordot : Sum products over arbitrary axes. +// einsum : Einstein summation convention. +// dot : alternative matrix product with different broadcasting rules. +// +// Notes +// ----- +// +// The behavior depends on the arguments in the following way. +// +// - If both arguments are 2-D they are multiplied like conventional +// matrices. +// - If either argument is N-D, N > 2, it is treated as a stack of +// matrices residing in the last two indexes and broadcast accordingly. +// - If the first argument is 1-D, it is promoted to a matrix by +// prepending a 1 to its dimensions. After matrix multiplication +// the prepended 1 is removed. +// - If the second argument is 1-D, it is promoted to a matrix by +// appending a 1 to its dimensions. After matrix multiplication +// the appended 1 is removed. +// +// ``matmul`` differs from ``dot`` in two important ways: +// +// - Multiplication by scalars is not allowed, use ``*`` instead. +// - Stacks of matrices are broadcast together as if the matrices +// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: +// +// >>> a = np.ones([9, 5, 7, 4]) +// >>> c = np.ones([9, 5, 4, 3]) +// >>> np.dot(a, c).shape +// (9, 5, 7, 9, 5, 3) +// >>> np.matmul(a, c).shape +// (9, 5, 7, 3) +// >>> # n is 7, k is 4, m is 3 +// +// The matmul function implements the semantics of the ``@`` operator +// introduced in Python 3.5 following :pep:`465`. +// +// It uses an optimized BLAS library when possible (see `numpy.linalg`). +// +// Examples +// -------- +// For 2-D arrays it is the matrix product: +// +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([[4, 1], +// ... [2, 2]]) +// >>> np.matmul(a, b) +// array([[4, 1], +// [2, 2]]) +// +// For 2-D mixed with 1-D, the result is the usual. +// +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([1, 2]) +// >>> np.matmul(a, b) +// array([1, 2]) +// >>> np.matmul(b, a) +// array([1, 2]) +// +// +// Broadcasting is conventional for stacks of arrays +// +// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) +// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) +// >>> np.matmul(a,b).shape +// (2, 2, 2) +// >>> np.matmul(a, b)[0, 1, 1] +// 98 +// >>> sum(a[0, 1, :] * b[0 , :, 1]) +// 98 +// +// Vector, vector returns the scalar inner product, but neither argument +// is complex-conjugated: +// +// >>> np.matmul([2j, 3j], [2j, 3j]) +// (-13+0j) +// +// Scalar multiplication raises an error. +// +// >>> np.matmul([1,2], 3) +// Traceback (most recent call last): +// ... +// ValueError: matmul: Input operand 1 does not have enough dimensions ... +// +// The ``@`` operator can be used as a shorthand for ``np.matmul`` on +// ndarrays. +// +// >>> x1 = np.array([2j, 3j]) +// >>> x2 = np.array([2j, 3j]) +// >>> x1 @ x2 +// (-13+0j) +// +// .. versionadded:: 1.10.0 +// +//go:linkname Matmul py.matmul +func Matmul(__llgo_va_list ...interface{}) *py.Object +// arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric inverse cosine, element-wise. +// +// The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``. +// +// Parameters +// ---------- +// x : array_like +// `x`-coordinate on the unit circle. +// For real arguments, the domain is [-1, 1]. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// The angle of the ray intersecting the unit circle at the given +// `x`-coordinate in radians [0, pi]. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// cos, arctan, arcsin, emath.arccos +// +// Notes +// ----- +// `arccos` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``cos(z) = x``. The convention is to return +// the angle `z` whose real part lies in `[0, pi]`. +// +// For real-valued input data types, `arccos` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse `cos` is also known as `acos` or cos^-1. +// +// References +// ---------- +// M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// We expect the arccos of 1 to be 0, and of -1 to be pi: +// +// >>> np.arccos([1, -1]) +// array([ 0. , 3.14159265]) +// +// Plot arccos: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-1, 1, num=100) +// >>> plt.plot(x, np.arccos(x)) +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Arccos py.arccos +func Arccos(__llgo_va_list ...interface{}) *py.Object +// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic cosine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// arccosh : ndarray +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// +// cosh, arcsinh, sinh, arctanh, tanh +// +// Notes +// ----- +// `arccosh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `cosh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in +// ``[0, inf]``. +// +// For real-valued input data types, `arccosh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `arccosh` is a complex analytical function that +// has a branch cut `[-inf, 1]` and is continuous from above on it. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arccosh +// +// Examples +// -------- +// >>> np.arccosh([np.e, 10.0]) +// array([ 1.65745445, 2.99322285]) +// >>> np.arccosh(1) +// 0.0 +// +//go:linkname Arccosh py.arccosh +func Arccosh(__llgo_va_list ...interface{}) *py.Object +// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse sine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// `y`-coordinate on the unit circle. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// The inverse sine of each element in `x`, in radians and in the +// closed interval ``[-pi/2, pi/2]``. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin +// +// Notes +// ----- +// `arcsin` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that :math:`sin(z) = x`. The convention is to +// return the angle `z` whose real part lies in [-pi/2, pi/2]. +// +// For real-valued input data types, *arcsin* always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse sine is also known as `asin` or sin^{-1}. +// +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79ff. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// >>> np.arcsin(1) # pi/2 +// 1.5707963267948966 +// >>> np.arcsin(-1) # -pi/2 +// -1.5707963267948966 +// >>> np.arcsin(0) +// 0.0 +// +//go:linkname Arcsin py.arcsin +func Arcsin(__llgo_va_list ...interface{}) *py.Object +// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic sine element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `arcsinh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `sinh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// +// For real-valued input data types, `arcsinh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// returns ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arcsinh +// +// Examples +// -------- +// >>> np.arcsinh(np.array([np.e, 10.0])) +// array([ 1.72538256, 2.99822295]) +// +//go:linkname Arcsinh py.arcsinh +func Arcsinh(__llgo_va_list ...interface{}) *py.Object +// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric inverse tangent, element-wise. +// +// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. +// +// Parameters +// ---------- +// x : array_like +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Out has the same shape as `x`. Its real part is in +// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) +// and the positive `x`-axis. +// angle : Argument of complex values. +// +// Notes +// ----- +// `arctan` is a multi-valued function: for each `x` there are infinitely +// many numbers `z` such that tan(`z`) = `x`. The convention is to return +// the angle `z` whose real part lies in [-pi/2, pi/2]. +// +// For real-valued input data types, `arctan` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse tangent is also known as `atan` or tan^{-1}. +// +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// We expect the arctan of 0 to be 0, and of 1 to be pi/4: +// +// >>> np.arctan([0, 1]) +// array([ 0. , 0.78539816]) +// +// >>> np.pi/4 +// 0.78539816339744828 +// +// Plot arctan: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-10, 10) +// >>> plt.plot(x, np.arctan(x)) +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Arctan py.arctan +func Arctan(__llgo_va_list ...interface{}) *py.Object +// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. +// +// 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`). (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). +// +// This function is not defined for complex-valued arguments; for the +// so-called argument of complex values, use `angle`. +// +// Parameters +// ---------- +// x1 : array_like, real-valued +// `y`-coordinates. +// x2 : array_like, real-valued +// `x`-coordinates. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// Array of angles in radians, in the range ``[-pi, pi]``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// arctan, tan, angle +// +// Notes +// ----- +// *arctan2* is identical to the `atan2` function of the underlying +// C library. The following special values are defined in the C +// standard: [1]_ +// +// ====== ====== ================ +// `x1` `x2` `arctan2(x1,x2)` +// ====== ====== ================ +// +/- 0 +0 +/- 0 +// +/- 0 -0 +/- pi +// > 0 +/-inf +0 / +pi +// < 0 +/-inf -0 / -pi +// +/-inf +inf +/- (pi/4) +// +/-inf -inf +/- (3*pi/4) +// ====== ====== ================ +// +// Note that +0 and -0 are distinct floating point numbers, as are +inf +// and -inf. +// +// References +// ---------- +// .. [1] ISO/IEC standard 9899:1999, "Programming language C." +// +// Examples +// -------- +// Consider four points in different quadrants: +// +// >>> x = np.array([-1, +1, +1, -1]) +// >>> y = np.array([-1, -1, +1, +1]) +// >>> np.arctan2(y, x) * 180 / np.pi +// array([-135., -45., 45., 135.]) +// +// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 +// and at several other special points, obtaining values in +// the range ``[-pi, pi]``: +// +// >>> np.arctan2([1., -1.], [0., 0.]) +// array([ 1.57079633, -1.57079633]) +// >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) +// array([0. , 3.14159265, 0.78539816]) +// +//go:linkname Arctan2 py.arctan2 +func Arctan2(__llgo_va_list ...interface{}) *py.Object +// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic tangent element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.arctanh +// +// Notes +// ----- +// `arctanh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``tanh(z) = x``. The convention is to return +// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// +// For real-valued input data types, `arctanh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arctanh +// +// Examples +// -------- +// >>> np.arctanh([0, -0.5]) +// array([ 0. , -0.54930614]) +// +//go:linkname Arctanh py.arctanh +func Arctanh(__llgo_va_list ...interface{}) *py.Object +// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise AND of two arrays element-wise. +// +// Computes the bit-wise AND of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``&``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and +// bitwise_or +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise AND of 13 and 17 is +// therefore ``000000001``, or 1: +// +// >>> np.bitwise_and(13, 17) +// 1 +// +// >>> np.bitwise_and(14, 13) +// 12 +// >>> np.binary_repr(12) +// '1100' +// >>> np.bitwise_and([14,3], 13) +// array([12, 1]) +// +// >>> np.bitwise_and([11,7], [4,25]) +// array([0, 1]) +// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) +// array([ 2, 4, 16]) +// >>> np.bitwise_and([True, True], [False, True]) +// array([False, True]) +// +// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([3, 14, 16]) +// >>> x1 & x2 +// array([ 2, 4, 16]) +// +//go:linkname BitwiseAnd py.bitwise_and +func BitwiseAnd(__llgo_va_list ...interface{}) *py.Object +// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise OR of two arrays element-wise. +// +// Computes the bit-wise OR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``|``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or +// bitwise_and +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 has the binary representation ``00001101``. Likewise, +// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is +// then ``00011101``, or 29: +// +// >>> np.bitwise_or(13, 16) +// 29 +// >>> np.binary_repr(29) +// '11101' +// +// >>> np.bitwise_or(32, 2) +// 34 +// >>> np.bitwise_or([33, 4], 1) +// array([33, 5]) +// >>> np.bitwise_or([33, 4], [1, 2]) +// array([33, 6]) +// +// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) +// array([ 6, 5, 255]) +// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) +// array([ 6, 5, 255]) +// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), +// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) +// array([ 6, 5, 255, 2147483647]) +// >>> np.bitwise_or([True, True], [False, True]) +// array([ True, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([4, 4, 4]) +// >>> x1 | x2 +// array([ 6, 5, 255]) +// +//go:linkname BitwiseOr py.bitwise_or +func BitwiseOr(__llgo_va_list ...interface{}) *py.Object +// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise XOR of two arrays element-wise. +// +// Computes the bit-wise XOR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``^``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_xor +// bitwise_and +// bitwise_or +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise XOR of 13 and 17 is +// therefore ``00011100``, or 28: +// +// >>> np.bitwise_xor(13, 17) +// 28 +// >>> np.binary_repr(28) +// '11100' +// +// >>> np.bitwise_xor(31, 5) +// 26 +// >>> np.bitwise_xor([31,3], 5) +// array([26, 6]) +// +// >>> np.bitwise_xor([31,3], [5,6]) +// array([26, 5]) +// >>> np.bitwise_xor([True, True], [False, True]) +// array([ True, False]) +// +// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on +// ndarrays. +// +// >>> x1 = np.array([True, True]) +// >>> x2 = np.array([False, True]) +// >>> x1 ^ x2 +// array([ True, False]) +// +//go:linkname BitwiseXor py.bitwise_xor +func BitwiseXor(__llgo_va_list ...interface{}) *py.Object +// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the cube-root of an array, element-wise. +// +// .. versionadded:: 1.10.0 +// +// Parameters +// ---------- +// x : array_like +// The values whose cube-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the cube +// cube-root of each element in `x`. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. +// +// +// Examples +// -------- +// >>> np.cbrt([1,8,27]) +// array([ 1., 2., 3.]) +// +//go:linkname Cbrt py.cbrt +func Cbrt(__llgo_va_list ...interface{}) *py.Object +// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the ceiling of the input, element-wise. +// +// The ceil of the scalar `x` is the smallest integer `i`, such that +// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The ceiling of each element in `x`, with `float` dtype. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// floor, trunc, rint, fix +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.ceil(a) +// array([-1., -1., -0., 1., 2., 2., 2.]) +// +//go:linkname Ceil py.ceil +func Ceil(__llgo_va_list ...interface{}) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conj py.conj +func Conj(__llgo_va_list ...interface{}) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conjugate py.conjugate +func Conjugate(__llgo_va_list ...interface{}) *py.Object +// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Change the sign of x1 to that of x2, element-wise. +// +// If `x2` is a scalar, its sign will be copied to all elements of `x1`. +// +// Parameters +// ---------- +// x1 : array_like +// Values to change the sign of. +// x2 : array_like +// The sign of `x2` is copied to `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The values of `x1` with the sign of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.copysign(1.3, -1) +// -1.3 +// >>> 1/np.copysign(0, 1) +// inf +// >>> 1/np.copysign(0, -1) +// -inf +// +// >>> np.copysign([-1, 0, 1], -1.1) +// array([-1., -0., -1.]) +// >>> np.copysign([-1, 0, 1], np.arange(3)-1) +// array([-1., 0., 1.]) +// +//go:linkname Copysign py.copysign +func Copysign(__llgo_va_list ...interface{}) *py.Object +// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Cosine element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding cosine values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. +// +// Examples +// -------- +// >>> np.cos(np.array([0, np.pi/2, np.pi])) +// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) +// >>> +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Cos py.cos +func Cos(__llgo_va_list ...interface{}) *py.Object +// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Hyperbolic cosine, element-wise. +// +// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array of same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.cosh(0) +// 1.0 +// +// The hyperbolic cosine describes the shape of a hanging cable: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-4, 4, 1000) +// >>> plt.plot(x, np.cosh(x)) +// >>> plt.show() +// +//go:linkname Cosh py.cosh +func Cosh(__llgo_va_list ...interface{}) *py.Object +// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Angles in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in radians. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : Convert angles from radians to degrees. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// ``deg2rad(x)`` is ``x * pi / 180``. +// +// Examples +// -------- +// >>> np.deg2rad(180) +// 3.1415926535897931 +// +//go:linkname Deg2rad py.deg2rad +func Deg2rad(__llgo_va_list ...interface{}) *py.Object +// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. +// +// Parameters +// ---------- +// x : array_like +// Input array in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray of floats +// The corresponding degree values; if `out` was supplied this is a +// reference to it. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : equivalent function +// +// Examples +// -------- +// Convert a radian array to degrees +// +// >>> rad = np.arange(12.)*np.pi/6 +// >>> np.degrees(rad) +// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., +// 270., 300., 330.]) +// +// >>> out = np.zeros((rad.shape)) +// >>> r = np.degrees(rad, out) +// >>> np.all(r == out) +// True +// +//go:linkname Degrees py.degrees +func Degrees(__llgo_va_list ...interface{}) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. +// +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. +// +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.divide(x1, x2) +// array([[nan, 1. , 1. ], +// [inf, 4. , 2.5], +// [inf, 7. , 4. ]]) +// +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) +// +//go:linkname Divide py.divide +func Divide(__llgo_va_list ...interface{}) *py.Object +// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return element-wise quotient and remainder simultaneously. +// +// .. versionadded:: 1.13.0 +// +// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster +// because it avoids redundant work. It is used to implement the Python +// built-in function ``divmod`` on NumPy arrays. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out1 : ndarray +// Element-wise quotient resulting from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// out2 : ndarray +// Element-wise remainder from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent to Python's ``//`` operator. +// remainder : Equivalent to Python's ``%`` operator. +// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return +// values switched. +// +// Examples +// -------- +// >>> np.divmod(np.arange(5), 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// +// The `divmod` function can be used as a shorthand for ``np.divmod`` on +// ndarrays. +// +// >>> x = np.arange(5) +// >>> divmod(x, 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// +//go:linkname Divmod py.divmod +func Divmod(__llgo_va_list ...interface{}) *py.Object +// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return (x1 == x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// not_equal, greater_equal, less_equal, greater, less +// +// Examples +// -------- +// >>> np.equal([0, 1, 3], np.arange(3)) +// array([ True, True, False]) +// +// What is compared are values, not types. So an int (1) and an array of +// length one can evaluate as True: +// +// >>> np.equal(1, np.ones(1)) +// array([ True]) +// +// The ``==`` operator can be used as a shorthand for ``np.equal`` on +// ndarrays. +// +// >>> a = np.array([2, 4, 6]) +// >>> b = np.array([2, 4, 2]) +// >>> a == b +// array([ True, True, False]) +// +//go:linkname Equal py.equal +func Equal(__llgo_va_list ...interface{}) *py.Object +// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the exponential of all elements in the input array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array, element-wise exponential of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. +// exp2 : Calculate ``2**x`` for all elements in the array. +// +// Notes +// ----- +// The irrational number ``e`` is also known as Euler's number. It is +// approximately 2.718281, and is the base of the natural logarithm, +// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, +// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. +// +// For complex arguments, ``x = a + ib``, we can write +// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already +// known (it is the real argument, described above). The second term, +// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with +// magnitude 1 and a periodic phase. +// +// References +// ---------- +// .. [1] Wikipedia, "Exponential function", +// https://en.wikipedia.org/wiki/Exponential_function +// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions +// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, +// https://personal.math.ubc.ca/~cbm/aands/page_69.htm +// +// Examples +// -------- +// Plot the magnitude and phase of ``exp(x)`` in the complex plane: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) +// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane +// >>> out = np.exp(xx) +// +// >>> plt.subplot(121) +// >>> plt.imshow(np.abs(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') +// >>> plt.title('Magnitude of exp(x)') +// +// >>> plt.subplot(122) +// >>> plt.imshow(np.angle(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') +// >>> plt.title('Phase (angle) of exp(x)') +// >>> plt.show() +// +//go:linkname Exp py.exp +func Exp(__llgo_va_list ...interface{}) *py.Object +// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate `2**p` for all `p` in the input array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise 2 to the power `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// power +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// +// +// Examples +// -------- +// >>> np.exp2([2, 3]) +// array([ 4., 8.]) +// +//go:linkname Exp2 py.exp2 +func Exp2(__llgo_va_list ...interface{}) *py.Object +// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate ``exp(x) - 1`` for all elements in the array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise exponential minus one: ``out = exp(x) - 1``. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log1p : ``log(1 + x)``, the inverse of expm1. +// +// +// Notes +// ----- +// This function provides greater precision than ``exp(x) - 1`` +// for small values of ``x``. +// +// Examples +// -------- +// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to +// about 32 significant digits. This example shows the superiority of +// expm1 in this case. +// +// >>> np.expm1(1e-10) +// 1.00000000005e-10 +// >>> np.exp(1e-10) - 1 +// 1.000000082740371e-10 +// +//go:linkname Expm1 py.expm1 +func Expm1(__llgo_va_list ...interface{}) *py.Object +// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the absolute values element-wise. +// +// This function returns the absolute values (positive magnitude) of the +// data in `x`. Complex values are not handled, use `absolute` to find the +// absolute values of complex data. +// +// Parameters +// ---------- +// x : array_like +// The array of numbers for which the absolute values are required. If +// `x` is a scalar, the result `y` will also be a scalar. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The absolute values of `x`, the returned values are always floats. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// absolute : Absolute values including `complex` types. +// +// Examples +// -------- +// >>> np.fabs(-1) +// 1.0 +// >>> np.fabs([-1.2, 1.2]) +// array([ 1.2, 1.2]) +// +//go:linkname Fabs py.fabs +func Fabs(__llgo_va_list ...interface{}) *py.Object +// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the floor of the input, element-wise. +// +// The floor of the scalar `x` is the largest integer `i`, such that +// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The floor of each element in `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ceil, trunc, rint, fix +// +// Notes +// ----- +// Some spreadsheet programs calculate the "floor-towards-zero", where +// ``floor(-2.5) == -2``. NumPy instead uses the definition of +// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" +// function is called ``fix`` in NumPy. +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.floor(a) +// array([-2., -2., -1., 0., 1., 1., 2.]) +// +//go:linkname Floor py.floor +func Floor(__llgo_va_list ...interface{}) *py.Object +// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the largest integer smaller or equal to the division of the inputs. +// It is equivalent to the Python ``//`` operator and pairs with the +// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` +// up to roundoff. +// +// Parameters +// ---------- +// x1 : array_like +// Numerator. +// x2 : array_like +// Denominator. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// y = floor(`x1`/`x2`) +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// remainder : Remainder complementary to floor_divide. +// divmod : Simultaneous floor division and remainder. +// divide : Standard division. +// floor : Round a number to the nearest integer toward minus infinity. +// ceil : Round a number to the nearest integer toward infinity. +// +// Examples +// -------- +// >>> np.floor_divide(7,3) +// 2 +// >>> np.floor_divide([1., 2., 3., 4.], 2.5) +// array([ 0., 0., 1., 1.]) +// +// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` +// on ndarrays. +// +// >>> x1 = np.array([1., 2., 3., 4.]) +// >>> x1 // 2.5 +// array([0., 0., 1., 1.]) +// +//go:linkname FloorDivide py.floor_divide +func FloorDivide(__llgo_va_list ...interface{}) *py.Object +// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// First array elements raised to powers from second array, element-wise. +// +// Raise each base in `x1` to the positionally-corresponding power in `x2`. +// `x1` and `x2` must be broadcastable to the same shape. This differs from +// the power function in that integers, float16, and float32 are promoted to +// floats with a minimum precision of float64 so that the result is always +// inexact. The intent is that the function will return a usable result for +// negative powers and seldom overflow for positive powers. +// +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). +// +// .. versionadded:: 1.12.0 +// +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// power : power function that preserves type +// +// Examples +// -------- +// Cube each element in a list. +// +// >>> x1 = range(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.float_power(x1, 3) +// array([ 0., 1., 8., 27., 64., 125.]) +// +// Raise the bases to different exponents. +// +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.float_power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) +// +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.float_power(x1, x2) +// array([[ 0., 1., 8., 27., 16., 5.], +// [ 0., 1., 8., 27., 16., 5.]]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1, -4]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.float_power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.float_power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname FloatPower py.float_power +func FloatPower(__llgo_va_list ...interface{}) *py.Object +// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise maximum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// minimum, amin, nanmin +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// +// Examples +// -------- +// >>> np.fmax([2, 3, 4], [1, 5, 2]) +// array([ 2., 5., 4.]) +// +// >>> np.fmax(np.eye(2), [0.5, 2]) +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) +// +//go:linkname Fmax py.fmax +func Fmax(__llgo_va_list ...interface{}) *py.Object +// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise minimum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// maximum, amax, nanmax +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// +// Examples +// -------- +// >>> np.fmin([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) +// +// >>> np.fmin(np.eye(2), [0.5, 2]) +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) +// +// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) +// +//go:linkname Fmin py.fmin +func Fmin(__llgo_va_list ...interface{}) *py.Object +// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// This is the NumPy implementation of the C library function fmod, the +// remainder has the same sign as the dividend `x1`. It is equivalent to +// the Matlab(TM) ``rem`` function and should not be confused with the +// Python modulus operator ``x1 % x2``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend. +// x2 : array_like +// Divisor. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : array_like +// The remainder of the division of `x1` by `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// remainder : Equivalent to the Python ``%`` operator. +// divide +// +// Notes +// ----- +// The result of the modulo operation for negative dividend and divisors +// is bound by conventions. For `fmod`, the sign of result is the sign of +// the dividend, while for `remainder` the sign of the result is the sign +// of the divisor. The `fmod` function is equivalent to the Matlab(TM) +// ``rem`` function. +// +// Examples +// -------- +// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) +// array([-1, 0, -1, 1, 0, 1]) +// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) +// array([1, 0, 1, 1, 0, 1]) +// +// >>> np.fmod([5, 3], [2, 2.]) +// array([ 1., 1.]) +// >>> a = np.arange(-3, 3).reshape(3, 2) +// >>> a +// array([[-3, -2], +// [-1, 0], +// [ 1, 2]]) +// >>> np.fmod(a, [2,2]) +// array([[-1, 0], +// [-1, 0], +// [ 1, 0]]) +// +//go:linkname Fmod py.fmod +func Fmod(__llgo_va_list ...interface{}) *py.Object +// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Decompose the elements of x into mantissa and twos exponent. +// +// Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``. +// The mantissa lies in the open interval(-1, 1), while the twos +// exponent is a signed integer. +// +// Parameters +// ---------- +// x : array_like +// Array of numbers to be decomposed. +// out1 : ndarray, optional +// Output array for the mantissa. Must have the same shape as `x`. +// out2 : ndarray, optional +// Output array for the exponent. Must have the same shape as `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// mantissa : ndarray +// Floating values between -1 and 1. +// This is a scalar if `x` is a scalar. +// exponent : ndarray +// Integer exponents of 2. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`. +// +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. +// +// Examples +// -------- +// >>> x = np.arange(9) +// >>> y1, y2 = np.frexp(x) +// >>> y1 +// array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, +// 0.5 ]) +// >>> y2 +// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) +// >>> y1 * 2**y2 +// array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) +// +//go:linkname Frexp py.frexp +func Frexp(__llgo_va_list ...interface{}) *py.Object +// gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the greatest common divisor of ``|x1|`` and ``|x2|`` +// +// Parameters +// ---------- +// x1, x2 : array_like, int +// Arrays of values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// +// Returns +// ------- +// y : ndarray or scalar +// The greatest common divisor of the absolute value of the inputs +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// lcm : The lowest common multiple +// +// Examples +// -------- +// >>> np.gcd(12, 20) +// 4 +// >>> np.gcd.reduce([15, 25, 35]) +// 5 +// >>> np.gcd(np.arange(6), 20) +// array([20, 1, 2, 1, 4, 5]) +// +//go:linkname Gcd py.gcd +func Gcd(__llgo_va_list ...interface{}) *py.Object +// greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 > x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// +// See Also +// -------- +// greater_equal, less, less_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.greater([4,2],[2,2]) +// array([ True, False]) +// +// The ``>`` operator can be used as a shorthand for ``np.greater`` on +// ndarrays. +// +// >>> a = np.array([4, 2]) +// >>> b = np.array([2, 2]) +// >>> a > b +// array([ True, False]) +// +//go:linkname Greater py.greater +func Greater(__llgo_va_list ...interface{}) *py.Object +// greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 >= x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : bool or ndarray of bool +// 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. +// +// See Also +// -------- +// greater, less, less_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.greater_equal([4, 2, 1], [2, 2, 2]) +// array([ True, True, False]) +// +// The ``>=`` operator can be used as a shorthand for ``np.greater_equal`` +// on ndarrays. +// +// >>> a = np.array([4, 2, 1]) +// >>> b = np.array([2, 2, 2]) +// >>> a >= b +// array([ True, True, False]) +// +//go:linkname GreaterEqual py.greater_equal +func GreaterEqual(__llgo_va_list ...interface{}) *py.Object +// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the Heaviside step function. +// +// The Heaviside step function is defined as:: +// +// 0 if x1 < 0 +// heaviside(x1, x2) = x2 if x1 == 0 +// 1 if x1 > 0 +// +// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. +// +// Parameters +// ---------- +// x1 : array_like +// Input values. +// x2 : array_like +// The value of the function when x1 is 0. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The output array, element-wise Heaviside step function of `x1`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// .. versionadded:: 1.13.0 +// +// References +// ---------- +// .. Wikipedia, "Heaviside step function", +// https://en.wikipedia.org/wiki/Heaviside_step_function +// +// Examples +// -------- +// >>> np.heaviside([-1.5, 0, 2.0], 0.5) +// array([ 0. , 0.5, 1. ]) +// >>> np.heaviside([-1.5, 0, 2.0], 1) +// array([ 0., 1., 1.]) +// +//go:linkname Heaviside py.heaviside +func Heaviside(__llgo_va_list ...interface{}) *py.Object +// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Given the "legs" of a right triangle, return its hypotenuse. +// +// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. 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. +// (See Examples) +// +// Parameters +// ---------- +// x1, x2 : array_like +// Leg of the triangle(s). +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// z : ndarray +// The hypotenuse of the triangle(s). +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) +// +// Example showing broadcast of scalar_like argument: +// +// >>> np.hypot(3*np.ones((3, 3)), [4]) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) +// +//go:linkname Hypot py.hypot +func Hypot(__llgo_va_list ...interface{}) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. +// +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: +// +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' +// +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) +// +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) +// +//go:linkname Invert py.invert +func Invert(__llgo_va_list ...interface{}) *py.Object +// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for finiteness (not infinity and not Not a Number). +// +// The result is returned as a boolean array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray, bool +// True where ``x`` is not positive infinity, negative infinity, +// or NaN; false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isinf, isneginf, isposinf, isnan +// +// 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. +// +// Examples +// -------- +// >>> np.isfinite(1) +// True +// >>> np.isfinite(0) +// True +// >>> np.isfinite(np.nan) +// False +// >>> np.isfinite(np.inf) +// False +// >>> np.isfinite(np.NINF) +// False +// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) +// array([False, True, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isfinite(x, y) +// array([0, 1, 0]) +// >>> y +// array([0, 1, 0]) +// +//go:linkname Isfinite py.isfinite +func Isfinite(__llgo_va_list ...interface{}) *py.Object +// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for positive or negative infinity. +// +// Returns a boolean array of the same shape as `x`, True where ``x == +// +/-inf``, otherwise False. +// +// Parameters +// ---------- +// x : array_like +// Input values +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool (scalar) or boolean ndarray +// True where ``x`` is positive or negative infinity, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isneginf, isposinf, isnan, isfinite +// +// 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. +// +// Examples +// -------- +// >>> np.isinf(np.inf) +// True +// >>> np.isinf(np.nan) +// False +// >>> np.isinf(np.NINF) +// True +// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) +// array([ True, True, False, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isinf(x, y) +// array([1, 0, 1]) +// >>> y +// array([1, 0, 1]) +// +//go:linkname Isinf py.isinf +func Isinf(__llgo_va_list ...interface{}) *py.Object +// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for NaN and return result as a boolean array. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaN, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isinf, isneginf, isposinf, isfinite, isnat +// +// 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. +// +// Examples +// -------- +// >>> np.isnan(np.nan) +// True +// >>> np.isnan(np.inf) +// False +// >>> np.isnan([np.log(-1.),1.,np.log(0)]) +// array([ True, False, False]) +// +//go:linkname Isnan py.isnan +func Isnan(__llgo_va_list ...interface{}) *py.Object +// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for NaT (not a time) and return result as a boolean array. +// +// .. versionadded:: 1.13.0 +// +// Parameters +// ---------- +// x : array_like +// Input array with datetime or timedelta data type. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaT, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isnan, isinf, isneginf, isposinf, isfinite +// +// Examples +// -------- +// >>> np.isnat(np.datetime64("NaT")) +// True +// >>> np.isnat(np.datetime64("2016-01-01")) +// False +// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) +// array([ True, False]) +// +//go:linkname Isnat py.isnat +func Isnat(__llgo_va_list ...interface{}) *py.Object +// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` +// +// Parameters +// ---------- +// x1, x2 : array_like, int +// Arrays of values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// +// Returns +// ------- +// y : ndarray or scalar +// The lowest common multiple of the absolute value of the inputs +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// gcd : The greatest common divisor +// +// Examples +// -------- +// >>> np.lcm(12, 20) +// 60 +// >>> np.lcm.reduce([3, 12, 20]) +// 60 +// >>> np.lcm.reduce([40, 12, 20]) +// 120 +// >>> np.lcm(np.arange(6), 20) +// array([ 0, 20, 20, 60, 20, 20]) +// +//go:linkname Lcm py.lcm +func Lcm(__llgo_va_list ...interface{}) *py.Object +// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns x1 * 2**x2, element-wise. +// +// The mantissas `x1` and twos exponents `x2` are used to construct +// floating point numbers ``x1 * 2**x2``. +// +// Parameters +// ---------- +// x1 : array_like +// Array of multipliers. +// x2 : array_like, int +// Array of twos exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The result of ``x1 * 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. +// +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. +// +// `ldexp` is useful as the inverse of `frexp`, if used by itself it is +// more clear to simply use the expression ``x1 * 2**x2``. +// +// Examples +// -------- +// >>> np.ldexp(5, np.arange(4)) +// array([ 5., 10., 20., 40.], dtype=float16) +// +// >>> x = np.arange(6) +// >>> np.ldexp(*np.frexp(x)) +// array([ 0., 1., 2., 3., 4., 5.]) +// +//go:linkname Ldexp py.ldexp +func Ldexp(__llgo_va_list ...interface{}) *py.Object +// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Shift the bits of an integer to the left. +// +// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. +// Since the internal representation of numbers is in binary format, this +// operation is equivalent to multiplying `x1` by ``2**x2``. +// +// Parameters +// ---------- +// x1 : array_like of integer type +// Input values. +// x2 : array_like of integer type +// Number of zeros to append to `x1`. Has to be non-negative. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : array of integer type +// Return `x1` with bits shifted `x2` times to the left. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// right_shift : Shift the bits of an integer to the right. +// binary_repr : Return the binary representation of the input number +// as a string. +// +// Examples +// -------- +// >>> np.binary_repr(5) +// '101' +// >>> np.left_shift(5, 2) +// 20 +// >>> np.binary_repr(20) +// '10100' +// +// >>> np.left_shift(5, [1,2,3]) +// array([10, 20, 40]) +// +// Note that the dtype of the second argument may change the dtype of the +// result and can lead to unexpected results in some cases (see +// :ref:`Casting Rules `): +// +// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 +// >>> print(a, type(a)) # Unexpected result due to upcasting +// 510 +// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) +// >>> print(b, type(b)) +// 254 +// +// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on +// ndarrays. +// +// >>> x1 = 5 +// >>> x2 = np.array([1, 2, 3]) +// >>> x1 << x2 +// array([10, 20, 40]) +// +//go:linkname LeftShift py.left_shift +func LeftShift(__llgo_va_list ...interface{}) *py.Object +// less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 < x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// greater, less_equal, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less([1, 2], [2, 2]) +// array([ True, False]) +// +// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. +// +// >>> a = np.array([1, 2]) +// >>> b = np.array([2, 2]) +// >>> a < b +// array([ True, False]) +// +//go:linkname Less py.less +func Less(__llgo_va_list ...interface{}) *py.Object +// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 <= x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// greater, less, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less_equal([4, 2, 1], [2, 2, 2]) +// array([False, True, True]) +// +// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on +// ndarrays. +// +// >>> a = np.array([4, 2, 1]) +// >>> b = np.array([2, 2, 2]) +// >>> a <= b +// array([False, True, True]) +// +//go:linkname LessEqual py.less_equal +func LessEqual(__llgo_va_list ...interface{}) *py.Object +// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Natural logarithm, element-wise. +// +// The natural logarithm `log` is the inverse of the exponential function, +// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base +// `e`. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The natural logarithm of `x`, element-wise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log10, log2, log1p, emath.log +// +// Notes +// ----- +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log` always returns real output. For +// each value that cannot be expressed as a real number or infinity, it +// yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log([1, np.e, np.e**2, 0]) +// array([ 0., 1., 2., -Inf]) +// +//go:linkname Log py.log +func Log(__llgo_va_list ...interface{}) *py.Object +// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the base 10 logarithm of the input array, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The logarithm to the base 10 of `x`, element-wise. NaNs are +// returned where x is negative. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.log10 +// +// Notes +// ----- +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `10**z = x`. The convention is to return the +// `z` whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log10` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log10` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. +// `log10` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log10([1e-15, -3.]) +// array([-15., nan]) +// +//go:linkname Log10 py.log10 +func Log10(__llgo_va_list ...interface{}) *py.Object +// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the natural logarithm of one plus the input array, element-wise. +// +// Calculates ``log(1 + x)``. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Natural logarithm of `1 + x`, element-wise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// expm1 : ``exp(x) - 1``, the inverse of `log1p`. +// +// Notes +// ----- +// For real-valued input, `log1p` is accurate also for `x` so small +// that `1 + x == 1` in floating-point accuracy. +// +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = 1 + x`. The convention is to return +// the `z` whose imaginary part lies in `[-pi, pi]`. +// +// For real-valued input data types, `log1p` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log1p` is a complex analytical function that +// has a branch cut `[-inf, -1]` and is continuous from above on it. +// `log1p` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log1p(1e-99) +// 1e-99 +// >>> np.log(1 + 1e-99) +// 0.0 +// +//go:linkname Log1p py.log1p +func Log1p(__llgo_va_list ...interface{}) *py.Object +// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Base-2 logarithm of `x`. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Base-2 logarithm of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log, log10, log1p, emath.log2 +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `2**z = x`. The convention is to return the `z` +// whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log2` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log2` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// Examples +// -------- +// >>> x = np.array([0, 1, 2, 2**4]) +// >>> np.log2(x) +// array([-Inf, 0., 1., 4.]) +// +// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) +// >>> np.log2(xi) +// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) +// +//go:linkname Log2 py.log2 +func Log2(__llgo_va_list ...interface{}) *py.Object +// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Logarithm of the sum of exponentiations of the inputs. +// +// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in +// statistics where the calculated probabilities of events may be so small +// as to exceed the range of normal floating point numbers. In such cases +// the logarithm of the calculated probability is stored. This function +// allows adding probabilities stored in such a fashion. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray +// Logarithm of ``exp(x1) + exp(x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> prob1 = np.log(1e-50) +// >>> prob2 = np.log(2.5e-50) +// >>> prob12 = np.logaddexp(prob1, prob2) +// >>> prob12 +// -113.87649168120691 +// >>> np.exp(prob12) +// 3.5000000000000057e-50 +// +//go:linkname Logaddexp py.logaddexp +func Logaddexp(__llgo_va_list ...interface{}) *py.Object +// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Logarithm of the sum of exponentiations of the inputs in base-2. +// +// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine +// learning when the calculated probabilities of events may be so small as +// to exceed the range of normal floating point numbers. In such cases +// the base-2 logarithm of the calculated probability can be used instead. +// This function allows adding probabilities stored in such a fashion. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray +// Base-2 logarithm of ``2**x1 + 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logaddexp: Logarithm of the sum of exponentiations of the inputs. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> prob1 = np.log2(1e-50) +// >>> prob2 = np.log2(2.5e-50) +// >>> prob12 = np.logaddexp2(prob1, prob2) +// >>> prob1, prob2, prob12 +// (-166.09640474436813, -164.77447664948076, -164.28904982231052) +// >>> 2**prob12 +// 3.4999999999999914e-50 +// +//go:linkname Logaddexp2 py.logaddexp2 +func Logaddexp2(__llgo_va_list ...interface{}) *py.Object +// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 AND x2 element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// Boolean result of the logical AND operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or, logical_not, logical_xor +// bitwise_and +// +// Examples +// -------- +// >>> np.logical_and(True, False) +// False +// >>> np.logical_and([True, False], [False, False]) +// array([False, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_and(x>1, x<4) +// array([False, False, True, True, False]) +// +// +// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on +// boolean ndarrays. +// +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a & b +// array([False, False]) +// +//go:linkname LogicalAnd py.logical_and +func LogicalAnd(__llgo_va_list ...interface{}) *py.Object +// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of NOT x element-wise. +// +// Parameters +// ---------- +// x : array_like +// Logical NOT is applied to the elements of `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool or ndarray of bool +// 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. +// +// See Also +// -------- +// logical_and, logical_or, logical_xor +// +// Examples +// -------- +// >>> np.logical_not(3) +// False +// >>> np.logical_not([True, False, 0, 1]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_not(x<3) +// array([False, False, False, True, True]) +// +//go:linkname LogicalNot py.logical_not +func LogicalNot(__llgo_va_list ...interface{}) *py.Object +// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 OR x2 element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Logical OR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// Boolean result of the logical OR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and, logical_not, logical_xor +// bitwise_or +// +// Examples +// -------- +// >>> np.logical_or(True, False) +// True +// >>> np.logical_or([True, False], [False, False]) +// array([ True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_or(x < 1, x > 3) +// array([ True, False, False, False, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on +// boolean ndarrays. +// +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a | b +// array([ True, False]) +// +//go:linkname LogicalOr py.logical_or +func LogicalOr(__llgo_va_list ...interface{}) *py.Object +// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 XOR x2, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Logical XOR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool or ndarray of bool +// Boolean result of the logical XOR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and, logical_or, logical_not, bitwise_xor +// +// Examples +// -------- +// >>> np.logical_xor(True, False) +// True +// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_xor(x < 1, x > 3) +// array([ True, False, False, False, True]) +// +// Simple example showing support of broadcasting +// +// >>> np.logical_xor(0, np.eye(2)) +// array([[ True, False], +// [False, True]]) +// +//go:linkname LogicalXor py.logical_xor +func LogicalXor(__llgo_va_list ...interface{}) *py.Object +// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise maximum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// fmin, amin, nanmin +// +// Notes +// ----- +// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when +// neither x1 nor x2 are nans, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.maximum([2, 3, 4], [1, 5, 2]) +// array([2, 5, 4]) +// +// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.maximum(np.Inf, 1) +// inf +// +//go:linkname Maximum py.maximum +func Maximum(__llgo_va_list ...interface{}) *py.Object +// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise minimum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// fmax, amax, nanmax +// +// Notes +// ----- +// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when +// neither x1 nor x2 are NaNs, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.minimum([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) +// +// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) +// +// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.minimum(-np.Inf, 1) +// -inf +// +//go:linkname Minimum py.minimum +func Minimum(__llgo_va_list ...interface{}) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. +// +// .. warning:: +// +// This should not be confused with: +// +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor +// +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. +// +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) +// +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Mod py.mod +func Mod(__llgo_va_list ...interface{}) *py.Object +// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the fractional and integral parts of an array, element-wise. +// +// The fractional and integral parts are negative if the given number is +// negative. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y1 : ndarray +// Fractional part of `x`. +// This is a scalar if `x` is a scalar. +// y2 : ndarray +// Integral part of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// For integer input the return values are floats. +// +// See Also +// -------- +// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values +// switched, except it always has a positive remainder. +// +// Examples +// -------- +// >>> np.modf([0, 3.5]) +// (array([ 0. , 0.5]), array([ 0., 3.])) +// >>> np.modf(-0.5) +// (-0.5, -0) +// +//go:linkname Modf py.modf +func Modf(__llgo_va_list ...interface{}) *py.Object +// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Multiply arguments element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays to be multiplied. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The product of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to `x1` * `x2` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.multiply(2.0, 4.0) +// 8.0 +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.multiply(x1, x2) +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) +// +// The ``*`` operator can be used as a shorthand for ``np.multiply`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 * x2 +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) +// +//go:linkname Multiply py.multiply +func Multiply(__llgo_va_list ...interface{}) *py.Object +// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Numerical negative, element-wise. +// +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = -x`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.negative([1.,-1.]) +// array([-1., 1.]) +// +// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on +// ndarrays. +// +// >>> x1 = np.array(([1., -1.])) +// >>> -x1 +// array([-1., 1.]) +// +//go:linkname Negative py.negative +func Negative(__llgo_va_list ...interface{}) *py.Object +// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the next floating-point value after x1 towards x2, element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Values to find the next representable value of. +// x2 : array_like +// The direction where to look for the next representable value of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The next representable values of `x1` in the direction of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> eps = np.finfo(np.float64).eps +// >>> np.nextafter(1, 2) == eps + 1 +// True +// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] +// array([ True, True]) +// +//go:linkname Nextafter py.nextafter +func Nextafter(__llgo_va_list ...interface{}) *py.Object +// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return (x1 != x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// equal, greater, greater_equal, less, less_equal +// +// Examples +// -------- +// >>> np.not_equal([1.,2.], [1., 3.]) +// array([False, True]) +// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) +// array([[False, True], +// [False, True]]) +// +// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on +// ndarrays. +// +// >>> a = np.array([1., 2.]) +// >>> b = np.array([1., 3.]) +// >>> a != b +// array([False, True]) +// +//go:linkname NotEqual py.not_equal +func NotEqual(__llgo_va_list ...interface{}) *py.Object +// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Numerical positive, element-wise. +// +// .. versionadded:: 1.13.0 +// +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = +x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// Equivalent to `x.copy()`, but only defined for types that support +// arithmetic. +// +// Examples +// -------- +// +// >>> x1 = np.array(([1., -1.])) +// >>> np.positive(x1) +// array([ 1., -1.]) +// +// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on +// ndarrays. +// +// >>> x1 = np.array(([1., -1.])) +// >>> +x1 +// array([ 1., -1.]) +// +//go:linkname Positive py.positive +func Positive(__llgo_va_list ...interface{}) *py.Object +// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// First array elements raised to powers from second array, element-wise. +// +// Raise each base in `x1` to the positionally-corresponding power in +// `x2`. `x1` and `x2` must be broadcastable to the same shape. +// +// An integer type raised to a negative integer power will raise a +// ``ValueError``. +// +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). +// +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// float_power : power function that promotes integers to float +// +// Examples +// -------- +// Cube each element in an array. +// +// >>> x1 = np.arange(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.power(x1, 3) +// array([ 0, 1, 8, 27, 64, 125]) +// +// Raise the bases to different exponents. +// +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) +// +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.power(x1, x2) +// array([[ 0, 1, 8, 27, 16, 5], +// [ 0, 1, 8, 27, 16, 5]]) +// +// The ``**`` operator can be used as a shorthand for ``np.power`` on +// ndarrays. +// +// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) +// >>> x1 = np.arange(6) +// >>> x1 ** x2 +// array([ 0, 1, 8, 27, 16, 5]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1.0, -4.0]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname Power py.power +func Power(__llgo_va_list ...interface{}) *py.Object +// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. +// +// Parameters +// ---------- +// x : array_like +// Angle in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in degrees. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// deg2rad : Convert angles from degrees to radians. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// rad2deg(x) is ``180 * x / pi``. +// +// Examples +// -------- +// >>> np.rad2deg(np.pi/2) +// 90.0 +// +//go:linkname Rad2deg py.rad2deg +func Rad2deg(__llgo_va_list ...interface{}) *py.Object +// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Input array in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding radian values. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// deg2rad : equivalent function +// +// Examples +// -------- +// Convert a degree array to radians +// +// >>> deg = np.arange(12.) * 30. +// >>> np.radians(deg) +// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , +// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, +// 5.23598776, 5.75958653]) +// +// >>> out = np.zeros((deg.shape)) +// >>> ret = np.radians(deg, out) +// >>> ret is out +// True +// +//go:linkname Radians py.radians +func Radians(__llgo_va_list ...interface{}) *py.Object +// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the reciprocal of the argument, element-wise. +// +// Calculates ``1/x``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Return array. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// .. note:: +// This function is not designed to work with integers. +// +// For integer arguments with absolute value larger than 1 the result is +// always zero because of the way Python handles integer division. For +// integer zero the result is an overflow. +// +// Examples +// -------- +// >>> np.reciprocal(2.) +// 0.5 +// >>> np.reciprocal([1, 2., 3.33]) +// array([ 1. , 0.5 , 0.3003003]) +// +//go:linkname Reciprocal py.reciprocal +func Reciprocal(__llgo_va_list ...interface{}) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. +// +// .. warning:: +// +// This should not be confused with: +// +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor +// +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. +// +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) +// +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Remainder py.remainder +func Remainder(__llgo_va_list ...interface{}) *py.Object +// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Shift the bits of an integer to the right. +// +// Bits are shifted to the right `x2`. Because the internal +// representation of numbers is in binary format, this operation is +// equivalent to dividing `x1` by ``2**x2``. +// +// Parameters +// ---------- +// x1 : array_like, int +// Input values. +// x2 : array_like, int +// Number of bits to remove at the right of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray, int +// Return `x1` with bits shifted `x2` times to the right. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// left_shift : Shift the bits of an integer to the left. +// binary_repr : Return the binary representation of the input number +// as a string. +// +// Examples +// -------- +// >>> np.binary_repr(10) +// '1010' +// >>> np.right_shift(10, 1) +// 5 +// >>> np.binary_repr(5) +// '101' +// +// >>> np.right_shift(10, [1,2,3]) +// array([5, 2, 1]) +// +// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on +// ndarrays. +// +// >>> x1 = 10 +// >>> x2 = np.array([1,2,3]) +// >>> x1 >> x2 +// array([5, 2, 1]) +// +//go:linkname RightShift py.right_shift +func RightShift(__llgo_va_list ...interface{}) *py.Object +// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Round elements of the array to the nearest integer. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array is same shape and type as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// fix, ceil, floor, trunc +// +// Notes +// ----- +// For values exactly halfway between rounded decimal values, NumPy +// rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, +// -0.5 and 0.5 round to 0.0, etc. +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.rint(a) +// array([-2., -2., -0., 0., 2., 2., 2.]) +// +//go:linkname Rint py.rint +func Rint(__llgo_va_list ...interface{}) *py.Object +// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns an element-wise indication of the sign of a number. +// +// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan +// is returned for nan inputs. +// +// For complex inputs, the `sign` function returns +// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. +// +// complex(nan, 0) is returned for complex nan inputs. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The sign of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// There is more than one definition of sign in common use for complex +// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` +// which is different from a common alternative, :math:`x/|x|`. +// +// Examples +// -------- +// >>> np.sign([-5., 4.5]) +// array([-1., 1.]) +// >>> np.sign(0) +// 0 +// >>> np.sign(5-2j) +// (1+0j) +// +//go:linkname Sign py.sign +func Sign(__llgo_va_list ...interface{}) *py.Object +// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns element-wise True where signbit is set (less than zero). +// +// Parameters +// ---------- +// x : array_like +// The input value(s). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray of bool +// Output array, or reference to `out` if that was supplied. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.signbit(-1.2) +// True +// >>> np.signbit(np.array([1, -2.3, 2.1])) +// array([False, True, False]) +// +//go:linkname Signbit py.signbit +func Signbit(__llgo_va_list ...interface{}) *py.Object +// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric sine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : array_like +// The sine of each element of x. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// arcsin, sinh, cos +// +// Notes +// ----- +// The sine is one of the fundamental functions of trigonometry (the +// mathematical study of triangles). Consider a circle of radius 1 +// centered on the origin. A ray comes in from the :math:`+x` axis, makes +// an angle at the origin (measured counter-clockwise from that axis), and +// departs from the origin. The :math:`y` coordinate of the outgoing +// ray's intersection with the unit circle is the sine of that angle. It +// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The +// function has zeroes where the angle is a multiple of :math:`\pi`. +// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. +// The numerous properties of the sine and related functions are included +// in any standard trigonometry text. +// +// Examples +// -------- +// Print sine of one angle: +// +// >>> np.sin(np.pi/2.) +// 1.0 +// +// Print sines of an array of angles given in degrees: +// +// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) +// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) +// +// Plot the sine function: +// +// >>> import matplotlib.pylab as plt +// >>> x = np.linspace(-np.pi, np.pi, 201) +// >>> plt.plot(x, np.sin(x)) +// >>> plt.xlabel('Angle [rad]') +// >>> plt.ylabel('sin(x)') +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Sin py.sin +func Sin(__llgo_va_list ...interface{}) *py.Object +// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Hyperbolic sine, element-wise. +// +// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or +// ``-1j * np.sin(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding hyperbolic sine values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// +// Examples +// -------- +// >>> np.sinh(0) +// 0.0 +// >>> np.sinh(np.pi*1j/2) +// 1j +// >>> np.sinh(np.pi*1j) # (exact value is 0) +// 1.2246063538223773e-016j +// >>> # Discrepancy due to vagaries of floating point arithmetic. +// +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.sinh([0.1], out1) +// >>> out2 is out1 +// True +// +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Sinh py.sinh +func Sinh(__llgo_va_list ...interface{}) *py.Object +// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the distance between x and the nearest adjacent number. +// +// Parameters +// ---------- +// x : array_like +// Values to find the spacing of. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The spacing of values of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// It can be considered as a generalization of EPS: +// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there +// should not be any representable number between ``x + spacing(x)`` and +// x for any finite x. +// +// Spacing of +- inf and NaN is NaN. +// +// Examples +// -------- +// >>> np.spacing(1) == np.finfo(np.float64).eps +// True +// +//go:linkname Spacing py.spacing +func Spacing(__llgo_va_list ...interface{}) *py.Object +// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the non-negative square-root of an array, element-wise. +// +// Parameters +// ---------- +// x : array_like +// The values whose square-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the positive +// square-root of each element in `x`. If any element in `x` is +// complex, a complex array is returned (and the square-roots of +// negative reals are calculated). If all of the elements in `x` +// are real, so is `y`, with negative elements returning ``nan``. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.sqrt +// A version which returns complex numbers when given negative reals. +// Note that 0.0 and -0.0 are handled differently for complex inputs. +// +// Notes +// ----- +// *sqrt* has--consistent with common convention--as its branch cut the +// real "interval" [`-inf`, 0), and is continuous from above on it. +// A branch cut is a curve in the complex plane across which a given +// complex function fails to be continuous. +// +// Examples +// -------- +// >>> np.sqrt([1,4,9]) +// array([ 1., 2., 3.]) +// +// >>> np.sqrt([4, -1, -3+4J]) +// array([ 2.+0.j, 0.+1.j, 1.+2.j]) +// +// >>> np.sqrt([4, -1, np.inf]) +// array([ 2., nan, inf]) +// +//go:linkname Sqrt py.sqrt +func Sqrt(__llgo_va_list ...interface{}) *py.Object +// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the element-wise square of the input. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise `x*x`, of the same shape and dtype as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// numpy.linalg.matrix_power +// sqrt +// power +// +// Examples +// -------- +// >>> np.square([-1j, 1]) +// array([-1.-0.j, 1.+0.j]) +// +//go:linkname Square py.square +func Square(__llgo_va_list ...interface{}) *py.Object +// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Subtract arguments, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays to be subtracted from each other. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The difference of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to ``x1 - x2`` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.subtract(1.0, 4.0) +// -3.0 +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.subtract(x1, x2) +// array([[ 0., 0., 0.], +// [ 3., 3., 3.], +// [ 6., 6., 6.]]) +// +// The ``-`` operator can be used as a shorthand for ``np.subtract`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 - x2 +// array([[0., 0., 0.], +// [3., 3., 3.], +// [6., 6., 6.]]) +// +//go:linkname Subtract py.subtract +func Subtract(__llgo_va_list ...interface{}) *py.Object +// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute tangent element-wise. +// +// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding tangent values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. +// +// Examples +// -------- +// >>> from math import pi +// >>> np.tan(np.array([-pi,pi/2,pi])) +// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) +// >>> +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Tan py.tan +func Tan(__llgo_va_list ...interface{}) *py.Object +// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute hyperbolic tangent element-wise. +// +// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding hyperbolic tangent values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// https://personal.math.ubc.ca/~cbm/aands/page_83.htm +// +// .. [2] Wikipedia, "Hyperbolic function", +// https://en.wikipedia.org/wiki/Hyperbolic_function +// +// Examples +// -------- +// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) +// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) +// +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.tanh([0.1], out1) +// >>> out2 is out1 +// True +// +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Tanh py.tanh +func Tanh(__llgo_va_list ...interface{}) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. +// +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. +// +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.divide(x1, x2) +// array([[nan, 1. , 1. ], +// [inf, 4. , 2.5], +// [inf, 7. , 4. ]]) +// +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) +// +//go:linkname TrueDivide py.true_divide +func TrueDivide(__llgo_va_list ...interface{}) *py.Object +// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truncated value of the input, element-wise. +// +// The truncated value of the scalar `x` is the nearest integer `i` which +// is closer to zero than `x` is. In short, the fractional part of the +// signed number `x` is discarded. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The truncated value of each element in `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ceil, floor, rint, fix +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.trunc(a) +// array([-1., -1., -0., 0., 1., 1., 2.]) +// +//go:linkname Trunc py.trunc +func Trunc(__llgo_va_list ...interface{}) *py.Object +// +// Return the scalar dtype or NumPy equivalent of Python type of an object. +// +// Parameters +// ---------- +// rep : any +// The object of which the type is returned. +// default : any, optional +// If given, this is returned for objects whose types can not be +// determined. If not given, None is returned for those objects. +// +// Returns +// ------- +// dtype : dtype or Python type +// The data type of `rep`. +// +// See Also +// -------- +// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype +// +// Examples +// -------- +// >>> np.obj2sctype(np.int32) +// +// >>> np.obj2sctype(np.array([1., 2.])) +// +// >>> np.obj2sctype(np.array([1.j])) +// +// +// >>> np.obj2sctype(dict) +// +// >>> np.obj2sctype('string') +// +// >>> np.obj2sctype(1, default=list) +// +// +// +// +//go:linkname Obj2sctype py.obj2sctype +func Obj2sctype(rep *py.Object, default_ *py.Object) *py.Object +// +// Return the string representation of a scalar dtype. +// +// Parameters +// ---------- +// sctype : scalar dtype or object +// If a scalar dtype, the corresponding string character is +// returned. If an object, `sctype2char` tries to infer its scalar type +// and then return the corresponding string character. +// +// Returns +// ------- +// typechar : str +// The string character corresponding to the scalar type. +// +// Raises +// ------ +// ValueError +// If `sctype` is an object for which the type can not be inferred. +// +// See Also +// -------- +// obj2sctype, issctype, issubsctype, mintypecode +// +// Examples +// -------- +// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: +// ... print(np.sctype2char(sctype)) +// l # may vary +// d +// D +// S +// O +// +// >>> x = np.array([1., 2-1.j]) +// >>> np.sctype2char(x) +// 'D' +// >>> np.sctype2char(list) +// 'O' +// +// +// +//go:linkname Sctype2char py.sctype2char +func Sctype2char(sctype *py.Object) *py.Object +// +// Return the scalar type of highest precision of the same kind as the input. +// +// Parameters +// ---------- +// t : dtype or dtype specifier +// The input data type. This can be a `dtype` object or an object that +// is convertible to a `dtype`. +// +// Returns +// ------- +// out : dtype +// The highest precision data type of the same kind (`dtype.kind`) as `t`. +// +// See Also +// -------- +// obj2sctype, mintypecode, sctype2char +// dtype +// +// Examples +// -------- +// >>> np.maximum_sctype(int) +// +// >>> np.maximum_sctype(np.uint8) +// +// >>> np.maximum_sctype(complex) +// # may vary +// +// >>> np.maximum_sctype(str) +// +// +// >>> np.maximum_sctype('i2') +// +// >>> np.maximum_sctype('f4') +// # may vary +// +// +// +//go:linkname MaximumSctype py.maximum_sctype +func MaximumSctype(t *py.Object) *py.Object +// +// Determines whether the given object represents a scalar data-type. +// +// Parameters +// ---------- +// rep : any +// If `rep` is an instance of a scalar dtype, True is returned. If not, +// False is returned. +// +// Returns +// ------- +// out : bool +// Boolean result of check whether `rep` is a scalar dtype. +// +// See Also +// -------- +// issubsctype, issubdtype, obj2sctype, sctype2char +// +// Examples +// -------- +// >>> np.issctype(np.int32) +// True +// >>> np.issctype(list) +// False +// >>> np.issctype(1.1) +// False +// +// Strings are also a scalar type: +// +// >>> np.issctype(np.dtype('str')) +// True +// +// +// +//go:linkname Issctype py.issctype +func Issctype(rep *py.Object) *py.Object +// +// Determine common type following standard coercion rules. +// +// .. deprecated:: NumPy 1.25 +// +// This function is deprecated, use `numpy.promote_types` or +// `numpy.result_type` instead. To achieve semantics for the +// `scalar_types` argument, use `numpy.result_type` and pass the Python +// values `0`, `0.0`, or `0j`. +// This will give the same results in almost all cases. +// More information and rare exception can be found in the +// `NumPy 1.25 release notes `_. +// +// Parameters +// ---------- +// array_types : sequence +// A list of dtypes or dtype convertible objects representing arrays. +// scalar_types : sequence +// A list of dtypes or dtype convertible objects representing scalars. +// +// Returns +// ------- +// datatype : dtype +// The common data type, which is the maximum of `array_types` ignoring +// `scalar_types`, unless the maximum of `scalar_types` is of a +// different kind (`dtype.kind`). If the kind is not understood, then +// None is returned. +// +// See Also +// -------- +// dtype, common_type, can_cast, mintypecode +// +// Examples +// -------- +// >>> np.find_common_type([], [np.int64, np.float32, complex]) +// dtype('complex128') +// >>> np.find_common_type([np.int64, np.float32], []) +// dtype('float64') +// +// The standard casting rules ensure that a scalar cannot up-cast an +// array unless the scalar is of a fundamentally different kind of data +// (i.e. under a different hierarchy in the data type hierarchy) then +// the array: +// +// >>> np.find_common_type([np.float32], [np.int64, np.float64]) +// dtype('float32') +// +// Complex is of a different type, so it up-casts the float in the +// `array_types` argument: +// +// >>> np.find_common_type([np.float32], [complex]) +// dtype('complex128') +// +// Type specifier strings are convertible to dtypes and can therefore +// be used instead of dtypes: +// +// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) +// dtype('complex128') +// +// +// +//go:linkname FindCommonType py.find_common_type +func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object +// +// Returns True if first argument is a typecode lower/equal in type hierarchy. +// +// This is like the builtin :func:`issubclass`, but for `dtype`\ s. +// +// Parameters +// ---------- +// arg1, arg2 : dtype_like +// `dtype` or object coercible to one +// +// Returns +// ------- +// out : bool +// +// See Also +// -------- +// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. +// issubsctype, issubclass_ +// +// Examples +// -------- +// `issubdtype` can be used to check the type of arrays: +// +// >>> ints = np.array([1, 2, 3], dtype=np.int32) +// >>> np.issubdtype(ints.dtype, np.integer) +// True +// >>> np.issubdtype(ints.dtype, np.floating) +// False +// +// >>> floats = np.array([1, 2, 3], dtype=np.float32) +// >>> np.issubdtype(floats.dtype, np.integer) +// False +// >>> np.issubdtype(floats.dtype, np.floating) +// True +// +// Similar types of different sizes are not subdtypes of each other: +// +// >>> np.issubdtype(np.float64, np.float32) +// False +// >>> np.issubdtype(np.float32, np.float64) +// False +// +// but both are subtypes of `floating`: +// +// >>> np.issubdtype(np.float64, np.floating) +// True +// >>> np.issubdtype(np.float32, np.floating) +// True +// +// For convenience, dtype-like objects are allowed too: +// +// >>> np.issubdtype('S1', np.string_) +// True +// >>> np.issubdtype('i4', np.signedinteger) +// True +// +// +// +//go:linkname Issubdtype py.issubdtype +func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Set a Python function to be used when pretty printing arrays. +// +// Parameters +// ---------- +// f : function or None +// Function to be used to pretty print arrays. The function should expect +// a single array argument and return a string of the representation of +// the array. If None, the function is reset to the default NumPy function +// to print arrays. +// repr : bool, optional +// If True (default), the function for pretty printing (``__repr__``) +// is set, if False the function that returns the default string +// representation (``__str__``) is set. +// +// See Also +// -------- +// set_printoptions, get_printoptions +// +// Examples +// -------- +// >>> def pprint(arr): +// ... return 'HA! - What are you going to do now?' +// ... +// >>> np.set_string_function(pprint) +// >>> a = np.arange(10) +// >>> a +// HA! - What are you going to do now? +// >>> _ = a +// >>> # [0 1 2 3 4 5 6 7 8 9] +// +// We can reset the function to the default: +// +// >>> np.set_string_function(None) +// >>> a +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// +// `repr` affects either pretty printing or normal string representation. +// Note that ``__repr__`` is still affected by setting ``__str__`` +// because the width of each array element in the returned string becomes +// equal to the length of the result of ``__str__()``. +// +// >>> x = np.arange(4) +// >>> np.set_string_function(lambda x:'random', repr=False) +// >>> x.__str__() +// 'random' +// >>> x.__repr__() +// 'array([0, 1, 2, 3])' +// +// +// +//go:linkname SetStringFunction py.set_string_function +func SetStringFunction(f *py.Object, repr *py.Object) *py.Object +// +// Set printing options. +// +// These options determine the way floating point numbers, arrays and +// other NumPy objects are displayed. +// +// Parameters +// ---------- +// precision : int or None, optional +// Number of digits of precision for floating point output (default 8). +// May be None if `floatmode` is not `fixed`, to print as many digits as +// necessary to uniquely specify the value. +// threshold : int, optional +// Total number of array elements which trigger summarization +// rather than full repr (default 1000). +// To always use the full repr without summarization, pass `sys.maxsize`. +// edgeitems : int, optional +// Number of array items in summary at beginning and end of +// each dimension (default 3). +// linewidth : int, optional +// The number of characters per line for the purpose of inserting +// line breaks (default 75). +// suppress : bool, optional +// If True, always print floating point numbers using fixed point +// notation, in which case numbers equal to zero in the current precision +// will print as zero. If False, then scientific notation is used when +// absolute value of the smallest number is < 1e-4 or the ratio of the +// maximum absolute value to the minimum is > 1e3. The default is False. +// nanstr : str, optional +// String representation of floating point not-a-number (default nan). +// infstr : str, optional +// String representation of floating point infinity (default inf). +// sign : string, either '-', '+', or ' ', optional +// Controls printing of the sign of floating-point types. If '+', always +// print the sign of positive values. If ' ', always prints a space +// (whitespace character) in the sign position of positive values. If +// '-', omit the sign character of positive values. (default '-') +// formatter : dict of callables, optional +// If not None, the keys should indicate the type(s) that the respective +// formatting function applies to. Callables should return a string. +// Types that are not specified (by their corresponding keys) are handled +// by the default formatters. Individual types for which a formatter +// can be set are: +// +// - 'bool' +// - 'int' +// - 'timedelta' : a `numpy.timedelta64` +// - 'datetime' : a `numpy.datetime64` +// - 'float' +// - 'longfloat' : 128-bit floats +// - 'complexfloat' +// - 'longcomplexfloat' : composed of two 128-bit floats +// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` +// - 'object' : `np.object_` arrays +// +// Other keys that can be used to set a group of types at once are: +// +// - 'all' : sets all types +// - 'int_kind' : sets 'int' +// - 'float_kind' : sets 'float' and 'longfloat' +// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' +// - 'str_kind' : sets 'numpystr' +// floatmode : str, optional +// Controls the interpretation of the `precision` option for +// floating-point types. Can take the following values +// (default maxprec_equal): +// +// * 'fixed': Always print exactly `precision` fractional digits, +// even if this would print more or fewer digits than +// necessary to specify the value uniquely. +// * 'unique': Print the minimum number of fractional digits necessary +// to represent each value uniquely. Different elements may +// have a different number of digits. The value of the +// `precision` option is ignored. +// * 'maxprec': Print at most `precision` fractional digits, but if +// an element can be uniquely represented with fewer digits +// only print it with that many. +// * 'maxprec_equal': Print at most `precision` fractional digits, +// but if every element in the array can be uniquely +// represented with an equal number of fewer digits, use that +// many digits for all elements. +// legacy : string or `False`, optional +// If set to the string `'1.13'` enables 1.13 legacy printing mode. This +// approximates numpy 1.13 print output by including a space in the sign +// position of floats and different behavior for 0d arrays. This also +// enables 1.21 legacy printing mode (described below). +// +// If set to the string `'1.21'` enables 1.21 legacy printing mode. This +// approximates numpy 1.21 print output of complex structured dtypes +// by not inserting spaces after commas that separate fields and after +// colons. +// +// If set to `False`, disables legacy mode. +// +// Unrecognized strings will be ignored with a warning for forward +// compatibility. +// +// .. versionadded:: 1.14.0 +// .. versionchanged:: 1.22.0 +// +// See Also +// -------- +// get_printoptions, printoptions, set_string_function, array2string +// +// Notes +// ----- +// `formatter` is always reset with a call to `set_printoptions`. +// +// Use `printoptions` as a context manager to set the values temporarily. +// +// Examples +// -------- +// Floating point precision can be set: +// +// >>> np.set_printoptions(precision=4) +// >>> np.array([1.123456789]) +// [1.1235] +// +// Long arrays can be summarised: +// +// >>> np.set_printoptions(threshold=5) +// >>> np.arange(10) +// array([0, 1, 2, ..., 7, 8, 9]) +// +// Small results can be suppressed: +// +// >>> eps = np.finfo(float).eps +// >>> x = np.arange(4.) +// >>> x**2 - (x + eps)**2 +// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) +// >>> np.set_printoptions(suppress=True) +// >>> x**2 - (x + eps)**2 +// array([-0., -0., 0., 0.]) +// +// A custom formatter can be used to display array elements as desired: +// +// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) +// >>> x = np.arange(3) +// >>> x +// array([int: 0, int: -1, int: -2]) +// >>> np.set_printoptions() # formatter gets reset +// >>> x +// array([0, 1, 2]) +// +// To put back the default options, you can use: +// +// >>> np.set_printoptions(edgeitems=3, infstr='inf', +// ... linewidth=75, nanstr='nan', precision=8, +// ... suppress=False, threshold=1000, formatter=None) +// +// Also to temporarily override options, use `printoptions` as a context manager: +// +// >>> with np.printoptions(precision=2, suppress=True, threshold=5): +// ... np.linspace(0, 10, 10) +// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) +// +// +// +//go:linkname SetPrintoptions py.set_printoptions +func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object +// +// Return the current print options. +// +// Returns +// ------- +// print_opts : dict +// Dictionary of current print options with keys +// +// - precision : int +// - threshold : int +// - edgeitems : int +// - linewidth : int +// - suppress : bool +// - nanstr : str +// - infstr : str +// - formatter : dict of callables +// - sign : str +// +// For a full description of these options, see `set_printoptions`. +// +// See Also +// -------- +// set_printoptions, printoptions, set_string_function +// +// +// +//go:linkname GetPrintoptions py.get_printoptions +func GetPrintoptions() *py.Object +// Context manager for setting print options. +// +// Set print options for the scope of the `with` block, and restore the old +// options at the end. See `set_printoptions` for the full description of +// available options. +// +// Examples +// -------- +// +// >>> from numpy.testing import assert_equal +// >>> with np.printoptions(precision=2): +// ... np.array([2.0]) / 3 +// array([0.67]) +// +// The `as`-clause of the `with`-statement gives the current print options: +// +// >>> with np.printoptions(precision=2) as opts: +// ... assert_equal(opts, np.get_printoptions()) +// +// See Also +// -------- +// set_printoptions, get_printoptions +// +// +// +//go:linkname Printoptions py.printoptions +func Printoptions(__llgo_va_list ...interface{}) *py.Object +// +// Format a floating-point scalar as a decimal string in positional notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed, or if `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// fractional : boolean, optional +// If `True`, the cutoffs of `precision` and `min_digits` refer to the +// total number of digits after the decimal point, including leading +// zeros. +// If `False`, `precision` and `min_digits` refer to the total number of +// significant digits, before or after the decimal point, ignoring leading +// zeros. +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// pad_right : non-negative integer, optional +// Pad the right side of the string with whitespace until at least that +// many characters are to the right of the decimal point. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. Only has an effect if `unique=True` +// in which case additional digits past those necessary to uniquely +// identify the value may be printed, rounding the last additional digit. +// +// -- versionadded:: 1.21.0 +// +// Returns +// ------- +// rep : string +// The string representation of the floating point value +// +// See Also +// -------- +// format_float_scientific +// +// Examples +// -------- +// >>> np.format_float_positional(np.float32(np.pi)) +// '3.1415927' +// >>> np.format_float_positional(np.float16(np.pi)) +// '3.14' +// >>> np.format_float_positional(np.float16(0.3)) +// '0.3' +// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) +// '0.3000488281' +// +// +//go:linkname FormatFloatPositional py.format_float_positional +func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object +// +// Format a floating-point scalar as a decimal string in scientific notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed. If `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// exp_digits : non-negative integer, optional +// Pad the exponent with zeros until it contains at least this many digits. +// If omitted, the exponent will be at least 2 digits. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. This only has an effect for +// `unique=True`. In that case more digits than necessary to uniquely +// identify the value may be printed and rounded unbiased. +// +// -- versionadded:: 1.21.0 +// +// Returns +// ------- +// rep : string +// The string representation of the floating point value +// +// See Also +// -------- +// format_float_positional +// +// Examples +// -------- +// >>> np.format_float_scientific(np.float32(np.pi)) +// '3.1415927e+00' +// >>> s = np.float32(1.23e24) +// >>> np.format_float_scientific(s, unique=False, precision=15) +// '1.230000071797338e+24' +// >>> np.format_float_scientific(s, exp_digits=4) +// '1.23e+0024' +// +// +//go:linkname FormatFloatScientific py.format_float_scientific +func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object +// +// Return an ndarray of the provided type that satisfies requirements. +// +// This function is useful to be sure that an array with the correct flags +// is returned for passing to compiled code (perhaps through ctypes). +// +// Parameters +// ---------- +// a : array_like +// The object to be converted to a type-and-requirement-satisfying array. +// dtype : data-type +// The required data-type. If None preserve the current dtype. If your +// application requires the data to be in native byteorder, include +// a byteorder specification as a part of the dtype specification. +// requirements : str or sequence of str +// The requirements list can be any of the following +// +// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array +// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array +// * 'ALIGNED' ('A') - ensure a data-type aligned array +// * 'WRITEABLE' ('W') - ensure a writable array +// * 'OWNDATA' ('O') - ensure an array that owns its own data +// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array with specified requirements and type if given. +// +// See Also +// -------- +// asarray : Convert input to an ndarray. +// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// ndarray.flags : Information about the memory layout of the array. +// +// Notes +// ----- +// The returned array will be guaranteed to have the listed requirements +// by making a copy if needed. +// +// Examples +// -------- +// >>> x = np.arange(6).reshape(2,3) +// >>> x.flags +// C_CONTIGUOUS : True +// F_CONTIGUOUS : False +// OWNDATA : False +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False +// +// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) +// >>> y.flags +// C_CONTIGUOUS : False +// F_CONTIGUOUS : True +// OWNDATA : True +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False +// +// +// +//go:linkname Require py.require +func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object +// +// Set how floating-point errors are handled. +// +// Note that operations on integer scalar types (such as `int16`) are +// handled like floating point, and are affected by these settings. +// +// Parameters +// ---------- +// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Set treatment for all types of floating-point errors at once: +// +// - ignore: Take no action when the exception occurs. +// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). +// - raise: Raise a `FloatingPointError`. +// - call: Call a function specified using the `seterrcall` function. +// - print: Print a warning directly to ``stdout``. +// - log: Record error in a Log object specified by `seterrcall`. +// +// The default is not to change the current behavior. +// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for division by zero. +// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point overflow. +// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point underflow. +// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for invalid floating-point operation. +// +// Returns +// ------- +// old_settings : dict +// Dictionary containing the old settings. +// +// See also +// -------- +// seterrcall : Set a callback function for the 'call' mode. +// geterr, geterrcall, errstate +// +// Notes +// ----- +// The floating-point exceptions are defined in the IEEE 754 standard [1]_: +// +// - Division by zero: infinite result obtained from finite numbers. +// - Overflow: result too large to be expressed. +// - Underflow: result so close to zero that some precision +// was lost. +// - Invalid operation: result is not an expressible number, typically +// indicates that a NaN was produced. +// +// .. [1] https://en.wikipedia.org/wiki/IEEE_754 +// +// Examples +// -------- +// >>> old_settings = np.seterr(all='ignore') #seterr to known value +// >>> np.seterr(over='raise') +// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} +// >>> np.seterr(**old_settings) # reset to default +// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} +// +// >>> np.int16(32000) * np.int16(3) +// 30464 +// >>> old_settings = np.seterr(all='warn', over='raise') +// >>> np.int16(32000) * np.int16(3) +// Traceback (most recent call last): +// File "", line 1, in +// FloatingPointError: overflow encountered in scalar multiply +// +// >>> old_settings = np.seterr(all='print') +// >>> np.geterr() +// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} +// >>> np.int16(32000) * np.int16(3) +// 30464 +// +// +// +//go:linkname Seterr py.seterr +func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object +// +// Get the current way of handling floating-point errors. +// +// Returns +// ------- +// res : dict +// A dictionary with keys "divide", "over", "under", and "invalid", +// whose values are from the strings "ignore", "print", "log", "warn", +// "raise", and "call". The keys represent possible floating-point +// exceptions, and the values define how these exceptions are handled. +// +// See Also +// -------- +// geterrcall, seterr, seterrcall +// +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. +// +// Examples +// -------- +// >>> np.geterr() +// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) +// +// >>> oldsettings = np.seterr(all='warn', over='raise') +// >>> np.geterr() +// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) +// +// +// +//go:linkname Geterr py.geterr +func Geterr() *py.Object +// +// Set the size of the buffer used in ufuncs. +// +// Parameters +// ---------- +// size : int +// Size of buffer. +// +// +// +//go:linkname Setbufsize py.setbufsize +func Setbufsize(size *py.Object) *py.Object +// +// Return the size of the buffer used in ufuncs. +// +// Returns +// ------- +// getbufsize : int +// Size of ufunc buffer in bytes. +// +// +// +//go:linkname Getbufsize py.getbufsize +func Getbufsize() *py.Object +// +// Set the floating-point error callback function or log object. +// +// There are two ways to capture floating-point error messages. The first +// is to set the error-handler to 'call', using `seterr`. Then, set +// the function to call using this function. +// +// The second is to set the error-handler to 'log', using `seterr`. +// Floating-point errors then trigger a call to the 'write' method of +// the provided object. +// +// Parameters +// ---------- +// func : callable f(err, flag) or object with write method +// Function to call upon floating-point errors ('call'-mode) or +// object whose 'write' method is used to log such message ('log'-mode). +// +// The call function takes two arguments. The first is a string describing +// the type of error (such as "divide by zero", "overflow", "underflow", +// or "invalid value"), and the second is the status flag. The flag is a +// byte, whose four least-significant bits indicate the type of error, one +// of "divide", "over", "under", "invalid":: +// +// [0 0 0 0 divide over under invalid] +// +// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. +// +// If an object is provided, its write method should take one argument, +// a string. +// +// Returns +// ------- +// h : callable, log instance or None +// The old error handler. +// +// See Also +// -------- +// seterr, geterr, geterrcall +// +// Examples +// -------- +// Callback upon error: +// +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// ... +// +// >>> saved_handler = np.seterrcall(err_handler) +// >>> save_err = np.seterr(all='call') +// +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) +// +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} +// +// Log error message: +// +// >>> class Log: +// ... def write(self, msg): +// ... print("LOG: %s" % msg) +// ... +// +// >>> log = Log() +// >>> saved_handler = np.seterrcall(log) +// >>> save_err = np.seterr(all='log') +// +// >>> np.array([1, 2, 3]) / 0.0 +// LOG: Warning: divide by zero encountered in divide +// array([inf, inf, inf]) +// +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} +// +// +// +//go:linkname Seterrcall py.seterrcall +func Seterrcall(func_ *py.Object) *py.Object +// +// Return the current callback function used on floating-point errors. +// +// When the error handling for a floating-point error (one of "divide", +// "over", "under", or "invalid") is set to 'call' or 'log', the function +// that is called or the log instance that is written to is returned by +// `geterrcall`. This function or log instance has been set with +// `seterrcall`. +// +// Returns +// ------- +// errobj : callable, log instance or None +// The current error handler. If no handler was set through `seterrcall`, +// ``None`` is returned. +// +// See Also +// -------- +// seterrcall, seterr, geterr +// +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. +// +// Examples +// -------- +// >>> np.geterrcall() # we did not yet set a handler, returns None +// +// >>> oldsettings = np.seterr(all='call') +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// >>> oldhandler = np.seterrcall(err_handler) +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) +// +// >>> cur_handler = np.geterrcall() +// >>> cur_handler is err_handler +// True +// +// +// +//go:linkname Geterrcall py.geterrcall +func Geterrcall() *py.Object +// +// Return a description for the given data type code. +// +// Parameters +// ---------- +// char : str +// Data type code. +// +// Returns +// ------- +// out : str +// Description of the input data type code. +// +// See Also +// -------- +// dtype, typecodes +// +// Examples +// -------- +// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', +// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] +// >>> for typechar in typechars: +// ... print(typechar, ' : ', np.typename(typechar)) +// ... +// S1 : character +// ? : bool +// B : unsigned char +// D : complex double precision +// G : complex long double precision +// F : complex single precision +// I : unsigned integer +// H : unsigned short +// L : unsigned long integer +// O : object +// Q : unsigned long long integer +// S : string +// U : unicode +// V : void +// b : signed char +// d : double precision +// g : long precision +// f : single precision +// i : integer +// h : short +// l : long integer +// q : long long integer +// +// +// +//go:linkname Typename py.typename +func Typename(char *py.Object) *py.Object +// +// Return the character for the minimum-size type to which given types can +// be safely cast. +// +// The returned type character must represent the smallest size dtype such +// that an array of the returned type can handle the data from an array of +// all types in `typechars` (or if `typechars` is an array, then its +// dtype.char). +// +// Parameters +// ---------- +// typechars : list of str or array_like +// If a list of strings, each string should represent a dtype. +// If array_like, the character representation of the array dtype is used. +// typeset : str or list of str, optional +// The set of characters that the returned character is chosen from. +// The default set is 'GDFgdf'. +// default : str, optional +// The default character, this is returned if none of the characters in +// `typechars` matches a character in `typeset`. +// +// Returns +// ------- +// typechar : str +// The character representing the minimum-size type that was found. +// +// See Also +// -------- +// dtype, sctype2char, maximum_sctype +// +// Examples +// -------- +// >>> np.mintypecode(['d', 'f', 'S']) +// 'd' +// >>> x = np.array([1.1, 2-3.j]) +// >>> np.mintypecode(x) +// 'D' +// +// >>> np.mintypecode('abceh', default='G') +// 'G' +// +// +// +//go:linkname Mintypecode py.mintypecode +func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *py.Object) *py.Object +// +// Return the indices to access the main diagonal of an array. +// +// This returns a tuple of indices that can be used to access the main +// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape +// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for +// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` +// for ``i = [0..n-1]``. +// +// Parameters +// ---------- +// n : int +// The size, along each dimension, of the arrays for which the returned +// indices can be used. +// +// ndim : int, optional +// The number of dimensions. +// +// See Also +// -------- +// diag_indices_from +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Create a set of indices to access the diagonal of a (4, 4) array: +// +// >>> di = np.diag_indices(4) +// >>> di +// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// >>> a[di] = 100 +// >>> a +// array([[100, 1, 2, 3], +// [ 4, 100, 6, 7], +// [ 8, 9, 100, 11], +// [ 12, 13, 14, 100]]) +// +// Now, we create indices to manipulate a 3-D array: +// +// >>> d3 = np.diag_indices(2, 3) +// >>> d3 +// (array([0, 1]), array([0, 1]), array([0, 1])) +// +// And use it to set the diagonal of an array of zeros to 1: +// +// >>> a = np.zeros((2, 2, 2), dtype=int) +// >>> a[d3] = 1 +// >>> a +// array([[[1, 0], +// [0, 0]], +// [[0, 0], +// [0, 1]]]) +// +// +// +//go:linkname DiagIndices py.diag_indices +func DiagIndices(n *py.Object, ndim *py.Object) *py.Object +// +// Check whether or not an object can be iterated over. +// +// Parameters +// ---------- +// y : object +// Input object. +// +// Returns +// ------- +// b : bool +// Return ``True`` if the object has an iterator method or is a +// sequence and ``False`` otherwise. +// +// +// Examples +// -------- +// >>> np.iterable([1, 2, 3]) +// True +// >>> np.iterable(2) +// False +// +// Notes +// ----- +// In most cases, the results of ``np.iterable(obj)`` are consistent with +// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is +// the treatment of 0-dimensional arrays:: +// +// >>> from collections.abc import Iterable +// >>> a = np.array(1.0) # 0-dimensional numpy array +// >>> isinstance(a, Iterable) +// True +// >>> np.iterable(a) +// False +// +// +// +//go:linkname Iterable py.iterable +func Iterable(y *py.Object) *py.Object +// +// Display a message on a device. +// +// Parameters +// ---------- +// mesg : str +// Message to display. +// device : object +// Device to write message. If None, defaults to ``sys.stdout`` which is +// very similar to ``print``. `device` needs to have ``write()`` and +// ``flush()`` methods. +// linefeed : bool, optional +// Option whether to print a line feed or not. Defaults to True. +// +// Raises +// ------ +// AttributeError +// If `device` does not have a ``write()`` or ``flush()`` method. +// +// Examples +// -------- +// Besides ``sys.stdout``, a file-like object can also be used as it has +// both required methods: +// +// >>> from io import StringIO +// >>> buf = StringIO() +// >>> np.disp(u'"Display" in a file', device=buf) +// >>> buf.getvalue() +// '"Display" in a file\n' +// +// +// +//go:linkname Disp py.disp +func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object +// Convert the input to an array, checking for NaNs or Infs. +// +// Parameters +// ---------- +// a : array_like +// Input data, in any form that can be converted to an array. This +// includes lists, lists of tuples, tuples, tuples of tuples, tuples +// of lists and ndarrays. Success requires no NaNs or Infs. +// dtype : data-type, optional +// By default, the data-type is inferred from the input data. +// order : {'C', 'F', 'A', 'K'}, optional +// Memory layout. 'A' and 'K' depend on the order of input array a. +// 'C' row-major (C-style), +// 'F' column-major (Fortran-style) memory representation. +// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise +// 'K' (keep) preserve input order +// Defaults to 'C'. +// +// Returns +// ------- +// out : ndarray +// Array interpretation of `a`. No copy is performed if the input +// is already an ndarray. If `a` is a subclass of ndarray, a base +// class ndarray is returned. +// +// Raises +// ------ +// ValueError +// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). +// +// See Also +// -------- +// asarray : Create and array. +// asanyarray : Similar function which passes through subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfarray : Convert input to a floating point ndarray. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// fromiter : Create an array from an iterator. +// fromfunction : Construct an array by executing a function on grid +// positions. +// +// Examples +// -------- +// Convert a list into an array. If all elements are finite +// ``asarray_chkfinite`` is identical to ``asarray``. +// +// >>> a = [1, 2] +// >>> np.asarray_chkfinite(a, dtype=float) +// array([1., 2.]) +// +// Raises ValueError if array_like contains Nans or Infs. +// +// >>> a = [1, 2, np.inf] +// >>> try: +// ... np.asarray_chkfinite(a) +// ... except ValueError: +// ... print('ValueError') +// ... +// ValueError +// +// +// +//go:linkname AsarrayChkfinite py.asarray_chkfinite +func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// Return the Hamming window. +// +// The Hamming window is a taper formed by using a weighted cosine. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hanning, kaiser +// +// Notes +// ----- +// The Hamming window is defined as +// +// .. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 +// +// The Hamming was named for R. W. Hamming, an associate of J. W. Tukey +// and is described in Blackman and Tukey. It was recommended for +// smoothing the truncated autocovariance function in the time domain. +// Most references to the Hamming window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 109-110. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// +// Examples +// -------- +// >>> np.hamming(12) +// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary +// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, +// 0.15302337, 0.08 ]) +// +// Plot the window and the frequency response: +// +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hamming(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hamming window") +// Text(0.5, 1.0, 'Hamming window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Hamming window") +// Text(0.5, 1.0, 'Frequency response of Hamming window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() +// +// +// +//go:linkname Hamming py.hamming +func Hamming(M *py.Object) *py.Object +// +// Return the Hanning window. +// +// The Hanning window is a taper formed by using a weighted cosine. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : ndarray, shape(M,) +// The window, with the maximum value normalized to one (the value +// one appears only if `M` is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, kaiser +// +// Notes +// ----- +// The Hanning window is defined as +// +// .. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 +// +// The Hanning was named for Julius von Hann, an Austrian meteorologist. +// It is also known as the Cosine Bell. Some authors prefer that it be +// called a Hann window, to help avoid confusion with the very similar +// Hamming window. +// +// Most references to the Hanning window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 106-108. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// +// Examples +// -------- +// >>> np.hanning(12) +// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, +// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, +// 0.07937323, 0. ]) +// +// Plot the window and its frequency response: +// +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hanning(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hann window") +// Text(0.5, 1.0, 'Hann window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of the Hann window") +// Text(0.5, 1.0, 'Frequency response of the Hann window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() +// +// +// +//go:linkname Hanning py.hanning +func Hanning(M *py.Object) *py.Object +// +// Return the Bartlett window. +// +// The Bartlett window is very similar to a triangular window, except +// that the end points are at zero. It is often used in signal +// processing for tapering a signal, without generating too much +// ripple in the frequency domain. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : array +// The triangular window, with the maximum value normalized to one +// (the value one appears only if the number of samples is odd), with +// the first and last samples equal to zero. +// +// See Also +// -------- +// blackman, hamming, hanning, kaiser +// +// Notes +// ----- +// The Bartlett window is defined as +// +// .. math:: w(n) = \frac{2}{M-1} \left( +// \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| +// \right) +// +// Most references to the Bartlett window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. Note that convolution with this window produces linear +// interpolation. It is also known as an apodization (which means "removing +// the foot", i.e. smoothing discontinuities at the beginning and end of the +// sampled signal) or tapering function. The Fourier transform of the +// Bartlett window is the product of two sinc functions. Note the excellent +// discussion in Kanasewich [2]_. +// +// References +// ---------- +// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", +// Biometrika 37, 1-16, 1950. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 109-110. +// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal +// Processing", Prentice-Hall, 1999, pp. 468-471. +// .. [4] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 429. +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.bartlett(12) +// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary +// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, +// 0.18181818, 0. ]) +// +// Plot the window and its frequency response (requires SciPy and matplotlib): +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.bartlett(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Bartlett window") +// Text(0.5, 1.0, 'Bartlett window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Bartlett window") +// Text(0.5, 1.0, 'Frequency response of Bartlett window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() +// +// +// +//go:linkname Bartlett py.bartlett +func Bartlett(M *py.Object) *py.Object +// +// Return the Blackman window. +// +// The Blackman window is a taper formed by using the first three +// terms of a summation of cosines. It was designed to have close to the +// minimal leakage possible. It is close to optimal, only slightly worse +// than a Kaiser window. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an empty +// array is returned. +// +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value one +// appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, hamming, hanning, kaiser +// +// Notes +// ----- +// The Blackman window is defined as +// +// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) +// +// Most references to the Blackman window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. It is known as a +// "near optimal" tapering function, almost as good (by some measures) +// as the kaiser window. +// +// References +// ---------- +// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, +// Dover Publications, New York. +// +// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. +// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.blackman(12) +// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary +// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, +// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, +// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) +// +// Plot the window and the frequency response: +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.blackman(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Blackman window") +// Text(0.5, 1.0, 'Blackman window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Blackman window") +// Text(0.5, 1.0, 'Frequency response of Blackman window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() +// +// +// +//go:linkname Blackman py.blackman +func Blackman(M *py.Object) *py.Object +// +// Return the Kaiser window. +// +// The Kaiser window is a taper formed by using a Bessel function. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// beta : float +// Shape parameter for window. +// +// Returns +// ------- +// out : array +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, hanning +// +// Notes +// ----- +// The Kaiser window is defined as +// +// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} +// \right)/I_0(\beta) +// +// with +// +// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, +// +// where :math:`I_0` is the modified zeroth-order Bessel function. +// +// The Kaiser was named for Jim Kaiser, who discovered a simple +// approximation to the DPSS window based on Bessel functions. The Kaiser +// window is a very good approximation to the Digital Prolate Spheroidal +// Sequence, or Slepian window, which is the transform which maximizes the +// energy in the main lobe of the window relative to total energy. +// +// The Kaiser can approximate many other windows by varying the beta +// parameter. +// +// ==== ======================= +// beta Window shape +// ==== ======================= +// 0 Rectangular +// 5 Similar to a Hamming +// 6 Similar to a Hanning +// 8.6 Similar to a Blackman +// ==== ======================= +// +// A beta value of 14 is probably a good starting point. Note that as beta +// gets large, the window narrows, and so the number of samples needs to be +// large enough to sample the increasingly narrow spike, otherwise NaNs will +// get returned. +// +// Most references to the Kaiser window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by +// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. +// John Wiley and Sons, New York, (1966). +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 177-178. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.kaiser(12, 14) +// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary +// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, +// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, +// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) +// +// +// Plot the window and the frequency response: +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.kaiser(51, 14) +// >>> plt.plot(window) +// [] +// >>> plt.title("Kaiser window") +// Text(0.5, 1.0, 'Kaiser window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Kaiser window") +// Text(0.5, 1.0, 'Frequency response of Kaiser window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// (-0.5, 0.5, -100.0, ...) # may vary +// >>> plt.show() +// +// +// +//go:linkname Kaiser py.kaiser +func Kaiser(M *py.Object, beta *py.Object) *py.Object +// +// Add documentation to an existing object, typically one defined in C +// +// The purpose is to allow easier editing of the docstrings without requiring +// a re-compile. This exists primarily for internal use within numpy itself. +// +// Parameters +// ---------- +// place : str +// The absolute name of the module to import from +// obj : str +// The name of the object to add documentation to, typically a class or +// function name +// doc : {str, Tuple[str, str], List[Tuple[str, str]]} +// If a string, the documentation to apply to `obj` +// +// If a tuple, then the first element is interpreted as an attribute of +// `obj` and the second as the docstring to apply - ``(method, docstring)`` +// +// If a list, then each element of the list should be a tuple of length +// two - ``[(method1, docstring1), (method2, docstring2), ...]`` +// warn_on_python : bool +// If True, the default, emit `UserWarning` if this is used to attach +// documentation to a pure-python object. +// +// Notes +// ----- +// This routine never raises an error if the docstring can't be written, but +// will raise an error if the object being documented does not exist. +// +// This routine cannot modify read-only docstrings, as appear +// in new-style classes or built-in functions. Because this +// routine never raises an error the caller must check manually +// that the docstrings were changed. +// +// Since this function grabs the ``char *`` from a c-level str object and puts +// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of +// C-API best-practices, by: +// +// - modifying a `PyTypeObject` after calling `PyType_Ready` +// - calling `Py_INCREF` on the str and losing the reference, so the str +// will never be released +// +// If possible it should be avoided. +// +// +//go:linkname AddNewdoc py.add_newdoc +func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object +// Find the wrapper for the array with the highest priority. +// +// In case of ties, leftmost wins. If no wrapper is found, return None +// +// +//go:linkname GetArrayWrap py.get_array_wrap +func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object +// +// Broadcast the input shapes into a single shape. +// +// :ref:`Learn more about broadcasting here `. +// +// .. versionadded:: 1.20.0 +// +// Parameters +// ---------- +// `*args` : tuples of ints, or ints +// The shapes to be broadcast against each other. +// +// Returns +// ------- +// tuple +// Broadcasted shape. +// +// Raises +// ------ +// ValueError +// If the shapes are not compatible and cannot be broadcast according +// to NumPy's broadcasting rules. +// +// See Also +// -------- +// broadcast +// broadcast_arrays +// broadcast_to +// +// Examples +// -------- +// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) +// (3, 2) +// +// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) +// (5, 6, 7) +// +// +//go:linkname BroadcastShapes py.broadcast_shapes +func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object +// +// Return a 2-D array with ones on the diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// Number of rows in the output. +// M : int, optional +// Number of columns in the output. If None, defaults to `N`. +// k : int, optional +// Index of the diagonal: 0 (the default) refers to the main diagonal, +// a positive value refers to an upper diagonal, and a negative value +// to a lower diagonal. +// dtype : data-type, optional +// Data-type of the returned array. +// order : {'C', 'F'}, optional +// Whether the output should be stored in row-major (C-style) or +// column-major (Fortran-style) order in memory. +// +// .. versionadded:: 1.14.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// I : ndarray of shape (N,M) +// An array where all elements are equal to zero, except for the `k`-th +// diagonal, whose values are equal to one. +// +// See Also +// -------- +// identity : (almost) equivalent function +// diag : diagonal 2-D array from a 1-D array specified by the user. +// +// Examples +// -------- +// >>> np.eye(2, dtype=int) +// array([[1, 0], +// [0, 1]]) +// >>> np.eye(3, k=1) +// array([[0., 1., 0.], +// [0., 0., 1.], +// [0., 0., 0.]]) +// +// +// +//go:linkname Eye py.eye +func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// An array with ones at and below the given diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// Number of rows in the array. +// M : int, optional +// Number of columns in the array. +// By default, `M` is taken equal to `N`. +// k : int, optional +// The sub-diagonal at and below which the array is filled. +// `k` = 0 is the main diagonal, while `k` < 0 is below it, +// and `k` > 0 is above. The default is 0. +// dtype : dtype, optional +// Data type of the returned array. The default is float. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// tri : ndarray of shape (N, M) +// Array with its lower triangle filled with ones and zero elsewhere; +// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. +// +// Examples +// -------- +// >>> np.tri(3, 5, 2, dtype=int) +// array([[1, 1, 1, 0, 0], +// [1, 1, 1, 1, 0], +// [1, 1, 1, 1, 1]]) +// +// >>> np.tri(3, 5, -1) +// array([[0., 0., 0., 0., 0.], +// [1., 0., 0., 0., 0.], +// [1., 1., 0., 0., 0.]]) +// +// +// +//go:linkname Tri py.tri +func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object +// +// Return the indices to access (n, n) arrays, given a masking function. +// +// Assume `mask_func` is a function that, for a square array a of size +// ``(n, n)`` with a possible offset argument `k`, when called as +// ``mask_func(a, k)`` returns a new array with zeros in certain locations +// (functions like `triu` or `tril` do precisely this). Then this function +// returns the indices where the non-zero values would be located. +// +// Parameters +// ---------- +// n : int +// The returned indices will be valid to access arrays of shape (n, n). +// mask_func : callable +// A function whose call signature is similar to that of `triu`, `tril`. +// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. +// `k` is an optional argument to the function. +// k : scalar +// An optional argument which is passed through to `mask_func`. Functions +// like `triu`, `tril` take a second argument that is interpreted as an +// offset. +// +// Returns +// ------- +// indices : tuple of arrays. +// The `n` arrays of indices corresponding to the locations where +// ``mask_func(np.ones((n, n)), k)`` is True. +// +// See Also +// -------- +// triu, tril, triu_indices, tril_indices +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// These are the indices that would allow you to access the upper triangular +// part of any 3x3 array: +// +// >>> iu = np.mask_indices(3, np.triu) +// +// For example, if `a` is a 3x3 array: +// +// >>> a = np.arange(9).reshape(3, 3) +// >>> a +// array([[0, 1, 2], +// [3, 4, 5], +// [6, 7, 8]]) +// >>> a[iu] +// array([0, 1, 2, 4, 5, 8]) +// +// An offset can be passed also to the masking function. This gets us the +// indices starting on the first diagonal right of the main one: +// +// >>> iu1 = np.mask_indices(3, np.triu, 1) +// +// with which we now extract only three elements: +// +// >>> a[iu1] +// array([1, 2, 5]) +// +// +// +//go:linkname MaskIndices py.mask_indices +func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object +// +// Return the indices for the lower-triangle of an (n, m) array. +// +// Parameters +// ---------- +// n : int +// The row dimension of the arrays for which the returned +// indices will be valid. +// k : int, optional +// Diagonal offset (see `tril` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// +// +// Returns +// ------- +// inds : tuple of arrays +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. +// +// See also +// -------- +// triu_indices : similar function, for upper-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// tril, triu +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Compute two different sets of indices to access 4x4 arrays, one for the +// lower triangular part starting at the main diagonal, and one starting two +// diagonals further right: +// +// >>> il1 = np.tril_indices(4) +// >>> il2 = np.tril_indices(4, 2) +// +// Here is how they can be used with a sample array: +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Both for indexing: +// +// >>> a[il1] +// array([ 0, 4, 5, ..., 13, 14, 15]) +// +// And for assigning values: +// +// >>> a[il1] = -1 +// >>> a +// array([[-1, 1, 2, 3], +// [-1, -1, 6, 7], +// [-1, -1, -1, 11], +// [-1, -1, -1, -1]]) +// +// These cover almost the whole array (two diagonals right of the main one): +// +// >>> a[il2] = -10 +// >>> a +// array([[-10, -10, -10, 3], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10]]) +// +// +// +//go:linkname TrilIndices py.tril_indices +func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Return the indices for the upper-triangle of an (n, m) array. +// +// Parameters +// ---------- +// n : int +// The size of the arrays for which the returned indices will +// be valid. +// k : int, optional +// Diagonal offset (see `triu` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// +// +// Returns +// ------- +// inds : tuple, shape(2) of ndarrays, shape(`n`) +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. Can be used +// to slice a ndarray of shape(`n`, `n`). +// +// See also +// -------- +// tril_indices : similar function, for lower-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// triu, tril +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Compute two different sets of indices to access 4x4 arrays, one for the +// upper triangular part starting at the main diagonal, and one starting two +// diagonals further right: +// +// >>> iu1 = np.triu_indices(4) +// >>> iu2 = np.triu_indices(4, 2) +// +// Here is how they can be used with a sample array: +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Both for indexing: +// +// >>> a[iu1] +// array([ 0, 1, 2, ..., 10, 11, 15]) +// +// And for assigning values: +// +// >>> a[iu1] = -1 +// >>> a +// array([[-1, -1, -1, -1], +// [ 4, -1, -1, -1], +// [ 8, 9, -1, -1], +// [12, 13, 14, -1]]) +// +// These cover only a small part of the whole array (two diagonals right +// of the main one): +// +// >>> a[iu2] = -10 +// >>> a +// array([[ -1, -1, -10, -10], +// [ 4, -1, -1, -10], +// [ 8, 9, -1, -1], +// [ 12, 13, 14, -1]]) +// +// +// +//go:linkname TriuIndices py.triu_indices +func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Determine if a class is a subclass of a second class. +// +// `issubclass_` is equivalent to the Python built-in ``issubclass``, +// except that it returns False instead of raising a TypeError if one +// of the arguments is not a class. +// +// Parameters +// ---------- +// arg1 : class +// Input class. True is returned if `arg1` is a subclass of `arg2`. +// arg2 : class or tuple of classes. +// Input class. If a tuple of classes, True is returned if `arg1` is a +// subclass of any of the tuple elements. +// +// Returns +// ------- +// out : bool +// Whether `arg1` is a subclass of `arg2` or not. +// +// See Also +// -------- +// issubsctype, issubdtype, issctype +// +// Examples +// -------- +// >>> np.issubclass_(np.int32, int) +// False +// >>> np.issubclass_(np.int32, float) +// False +// >>> np.issubclass_(np.float64, float) +// True +// +// +// +//go:linkname Issubclass py.issubclass_ +func Issubclass(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Determine if the first argument is a subclass of the second argument. +// +// Parameters +// ---------- +// arg1, arg2 : dtype or dtype specifier +// Data-types. +// +// Returns +// ------- +// out : bool +// The result. +// +// See Also +// -------- +// issctype, issubdtype, obj2sctype +// +// Examples +// -------- +// >>> np.issubsctype('S8', str) +// False +// >>> np.issubsctype(np.array([1]), int) +// True +// >>> np.issubsctype(np.array([1]), float) +// False +// +// +// +//go:linkname Issubsctype py.issubsctype +func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Issues a DeprecationWarning, adds warning to `old_name`'s +// docstring, rebinds ``old_name.__name__`` and returns the new +// function object. +// +// This function may also be used as a decorator. +// +// Parameters +// ---------- +// func : function +// The function to be deprecated. +// old_name : str, optional +// The name of the function to be deprecated. Default is None, in +// which case the name of `func` is used. +// new_name : str, optional +// The new name for the function. Default is None, in which case the +// deprecation message is that `old_name` is deprecated. If given, the +// deprecation message is that `old_name` is deprecated and `new_name` +// should be used instead. +// message : str, optional +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. +// +// Returns +// ------- +// old_func : function +// The deprecated function. +// +// Examples +// -------- +// Note that ``olduint`` returns a value after printing Deprecation +// Warning: +// +// >>> olduint = np.deprecate(np.uint) +// DeprecationWarning: `uint64` is deprecated! # may vary +// >>> olduint(6) +// 6 +// +// +// +//go:linkname Deprecate py.deprecate +func Deprecate(__llgo_va_list ...interface{}) *py.Object +// +// Deprecates a function and includes the deprecation in its docstring. +// +// This function is used as a decorator. It returns an object that can be +// used to issue a DeprecationWarning, by passing the to-be decorated +// function as argument, this adds warning to the to-be decorated function's +// docstring and returns the new function object. +// +// See Also +// -------- +// deprecate : Decorate a function such that it issues a `DeprecationWarning` +// +// Parameters +// ---------- +// msg : str +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. +// +// Returns +// ------- +// obj : object +// +// +// +//go:linkname DeprecateWithDoc py.deprecate_with_doc +func DeprecateWithDoc(msg *py.Object) *py.Object +// +// Return the directory that contains the NumPy \*.h header files. +// +// Extension modules that need to compile against NumPy should use this +// function to locate the appropriate include directory. +// +// Notes +// ----- +// When using ``distutils``, for example in ``setup.py``:: +// +// import numpy as np +// ... +// Extension('extension_name', ... +// include_dirs=[np.get_include()]) +// ... +// +// +// +//go:linkname GetInclude py.get_include +func GetInclude() *py.Object +// +// Get help information for an array, function, class, or module. +// +// Parameters +// ---------- +// object : object or str, optional +// Input object or name to get information about. If `object` is +// an `ndarray` instance, information about the array is printed. +// If `object` is a numpy object, its docstring is given. If it is +// a string, available modules are searched for matching objects. +// If None, information about `info` itself is returned. +// maxwidth : int, optional +// Printing width. +// output : file like object, optional +// File like object that the output is written to, default is +// ``None``, in which case ``sys.stdout`` will be used. +// The object has to be opened in 'w' or 'a' mode. +// toplevel : str, optional +// Start search at this level. +// +// See Also +// -------- +// source, lookfor +// +// Notes +// ----- +// When used interactively with an object, ``np.info(obj)`` is equivalent +// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython +// prompt. +// +// Examples +// -------- +// >>> np.info(np.polyval) # doctest: +SKIP +// polyval(p, x) +// Evaluate the polynomial p at x. +// ... +// +// When using a string for `object` it is possible to get multiple results. +// +// >>> np.info('fft') # doctest: +SKIP +// *** Found in numpy *** +// Core FFT routines +// ... +// *** Found in numpy.fft *** +// fft(a, n=None, axis=-1) +// ... +// *** Repeat reference found in numpy.fft.fftpack *** +// *** Total of 3 references found. *** +// +// When the argument is an array, information about the array is printed. +// +// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) +// >>> np.info(a) +// class: ndarray +// shape: (2, 3) +// strides: (24, 8) +// itemsize: 8 +// aligned: True +// contiguous: True +// fortran: False +// data pointer: 0x562b6e0d2860 # may vary +// byteorder: little +// byteswap: False +// type: complex64 +// +// +// +//go:linkname Info py.info +func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object +// +// Print or write to a file the source code for a NumPy object. +// +// The source code is only returned for objects written in Python. Many +// functions and classes are defined in C and will therefore not return +// useful information. +// +// Parameters +// ---------- +// object : numpy object +// Input object. This can be any object (function, class, module, +// ...). +// output : file object, optional +// If `output` not supplied then source code is printed to screen +// (sys.stdout). File object must be created with either write 'w' or +// append 'a' modes. +// +// See Also +// -------- +// lookfor, info +// +// Examples +// -------- +// >>> np.source(np.interp) #doctest: +SKIP +// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py +// def interp(x, xp, fp, left=None, right=None): +// """.... (full docstring printed)""" +// if isinstance(x, (float, int, number)): +// return compiled_interp([x], xp, fp, left, right).item() +// else: +// return compiled_interp(x, xp, fp, left, right) +// +// The source code is only returned for objects written in Python. +// +// >>> np.source(np.array) #doctest: +SKIP +// Not available for this object. +// +// +// +//go:linkname Source py.source +func Source(object *py.Object, output *py.Object) *py.Object +// +// Print the NumPy arrays in the given dictionary. +// +// If there is no dictionary passed in or `vardict` is None then returns +// NumPy arrays in the globals() dictionary (all NumPy arrays in the +// namespace). +// +// Parameters +// ---------- +// vardict : dict, optional +// A dictionary possibly containing ndarrays. Default is globals(). +// +// Returns +// ------- +// out : None +// Returns 'None'. +// +// Notes +// ----- +// Prints out the name, shape, bytes and type of all of the ndarrays +// present in `vardict`. +// +// Examples +// -------- +// >>> a = np.arange(10) +// >>> b = np.ones(20) +// >>> np.who() +// Name Shape Bytes Type +// =========================================================== +// a 10 80 int64 +// b 20 160 float64 +// Upper bound on total bytes = 240 +// +// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', +// ... 'idx':5} +// >>> np.who(d) +// Name Shape Bytes Type +// =========================================================== +// x 2 16 float64 +// y 3 24 float64 +// Upper bound on total bytes = 40 +// +// +// +//go:linkname Who py.who +func Who(vardict *py.Object) *py.Object +// +// Do a keyword search on docstrings. +// +// A list of objects that matched the search is displayed, +// sorted by relevance. All given keywords need to be found in the +// docstring for it to be returned as a result, but the order does +// not matter. +// +// Parameters +// ---------- +// what : str +// String containing words to look for. +// module : str or list, optional +// Name of module(s) whose docstrings to go through. +// import_modules : bool, optional +// Whether to import sub-modules in packages. Default is True. +// regenerate : bool, optional +// Whether to re-generate the docstring cache. Default is False. +// output : file-like, optional +// File-like object to write the output to. If omitted, use a pager. +// +// See Also +// -------- +// source, info +// +// Notes +// ----- +// Relevance is determined only roughly, by checking if the keywords occur +// in the function name, at the start of a docstring, etc. +// +// Examples +// -------- +// >>> np.lookfor('binary representation') # doctest: +SKIP +// Search results for 'binary representation' +// ------------------------------------------ +// numpy.binary_repr +// Return the binary representation of the input number as a string. +// numpy.core.setup_common.long_double_representation +// Given a binary dump as given by GNU od -b, look for long double +// numpy.base_repr +// Return a string representation of a number in the given base system. +// ... +// +// +// +//go:linkname Lookfor py.lookfor +func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object +// +// Returns pointers to the end-points of an array. +// +// Parameters +// ---------- +// a : ndarray +// Input array. It must conform to the Python-side of the array +// interface. +// +// Returns +// ------- +// (low, high) : tuple of 2 integers +// The first integer is the first byte of the array, the second +// integer is just past the last byte of the array. If `a` is not +// contiguous it will not use every byte between the (`low`, `high`) +// values. +// +// Examples +// -------- +// >>> I = np.eye(2, dtype='f'); I.dtype +// dtype('float32') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// >>> I = np.eye(2); I.dtype +// dtype('float64') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// +// +// +//go:linkname ByteBounds py.byte_bounds +func ByteBounds(a *py.Object) *py.Object +// +// Protected string evaluation. +// +// Evaluate a string containing a Python literal expression without +// allowing the execution of arbitrary non-literal code. +// +// .. warning:: +// +// This function is identical to :py:meth:`ast.literal_eval` and +// has the same security implications. It may not always be safe +// to evaluate large input strings. +// +// Parameters +// ---------- +// source : str +// The string to evaluate. +// +// Returns +// ------- +// obj : object +// The result of evaluating `source`. +// +// Raises +// ------ +// SyntaxError +// If the code has invalid Python syntax, or if it contains +// non-literal code. +// +// Examples +// -------- +// >>> np.safe_eval('1') +// 1 +// >>> np.safe_eval('[1, 2, 3]') +// [1, 2, 3] +// >>> np.safe_eval('{"foo": ("bar", 10.0)}') +// {'foo': ('bar', 10.0)} +// +// >>> np.safe_eval('import os') +// Traceback (most recent call last): +// ... +// SyntaxError: invalid syntax +// +// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') +// Traceback (most recent call last): +// ... +// ValueError: malformed node or string: <_ast.Call object at 0x...> +// +// +// +//go:linkname SafeEval py.safe_eval +func SafeEval(source *py.Object) *py.Object +// +// Print information about various resources in the system +// including available intrinsic support and BLAS/LAPACK library +// in use +// +// .. versionadded:: 1.24.0 +// +// See Also +// -------- +// show_config : Show libraries in the system on which NumPy was built. +// +// Notes +// ----- +// 1. Information is derived with the help of `threadpoolctl `_ +// library if available. +// 2. SIMD related information is derived from ``__cpu_features__``, +// ``__cpu_baseline__`` and ``__cpu_dispatch__`` +// +// +// +//go:linkname ShowRuntime py.show_runtime +func ShowRuntime() *py.Object +// +// Load data from a text file. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : data-type, optional +// Data-type of the resulting array; default: float. If this is a +// structured data-type, the resulting array will be 1-dimensional, and +// each row will be interpreted as an element of the array. In this +// case, the number of columns used must match the number of fields in +// the data-type. +// comments : str or sequence of str or None, optional +// The characters or list of characters used to indicate the start of a +// comment. None implies no comments. For backwards compatibility, byte +// strings will be decoded as 'latin1'. The default is '#'. +// delimiter : str, optional +// The character used to separate the values. For backwards compatibility, +// byte strings will be decoded as 'latin1'. The default is whitespace. +// +// .. versionchanged:: 1.23.0 +// Only single character delimiters are supported. Newline characters +// cannot be used as the delimiter. +// +// converters : dict or callable, optional +// Converter functions to customize value parsing. If `converters` is +// callable, the function is applied to all columns, else it must be a +// dict that maps column number to a parser function. +// See examples for further details. +// Default: None. +// +// .. versionchanged:: 1.23.0 +// The ability to pass a single callable to be applied to all columns +// was added. +// +// skiprows : int, optional +// Skip the first `skiprows` lines, including comments; default: 0. +// usecols : int or sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. +// The default, None, results in all columns being read. +// +// .. versionchanged:: 1.11.0 +// When a single column has to be read it is possible to use +// an integer instead of a tuple. E.g ``usecols = 3`` reads the +// fourth column the same way as ``usecols = (3,)`` would. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = loadtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// ndmin : int, optional +// The returned array will have at least `ndmin` dimensions. +// Otherwise mono-dimensional axes will be squeezed. +// Legal values: 0 (default), 1 or 2. +// +// .. versionadded:: 1.6.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply to input streams. +// The special value 'bytes' enables backward compatibility workarounds +// that ensures you receive byte arrays as results if possible and passes +// 'latin1' encoded strings to converters. Override this value to receive +// unicode arrays and pass strings as input to converters. If set to None +// the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// max_rows : int, optional +// Read `max_rows` rows of content after `skiprows` lines. The default is +// to read all the rows. Note that empty rows containing no data such as +// empty lines and comment lines are not counted towards `max_rows`, +// while such lines are counted in `skiprows`. +// +// .. versionadded:: 1.16.0 +// +// .. versionchanged:: 1.23.0 +// Lines containing no data, including comment lines (e.g., lines +// starting with '#' or as specified via `comments`) are not counted +// towards `max_rows`. +// quotechar : unicode character or None, optional +// The character used to denote the start and end of a quoted item. +// Occurrences of the delimiter or comment characters are ignored within +// a quoted item. The default value is ``quotechar=None``, which means +// quoting support is disabled. +// +// If two consecutive instances of `quotechar` are found within a quoted +// field, the first is treated as an escape character. See examples. +// +// .. versionadded:: 1.23.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Data read from the text file. +// +// See Also +// -------- +// load, fromstring, fromregex +// genfromtxt : Load data with missing values handled as specified. +// scipy.io.loadmat : reads MATLAB data files +// +// Notes +// ----- +// This function aims to be a fast reader for simply formatted files. The +// `genfromtxt` function provides more sophisticated handling of, e.g., +// lines with missing values. +// +// Each row in the input text file must have the same number of values to be +// able to read all values. If all rows do not have same number of values, a +// subset of up to n columns (where n is the least number of values present +// in all rows) can be read by specifying the columns via `usecols`. +// +// .. versionadded:: 1.10.0 +// +// The strings produced by the Python float.hex method can be used as +// input for floats. +// +// Examples +// -------- +// >>> from io import StringIO # StringIO behaves like a file object +// >>> c = StringIO("0 1\n2 3") +// >>> np.loadtxt(c) +// array([[0., 1.], +// [2., 3.]]) +// +// >>> d = StringIO("M 21 72\nF 35 58") +// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), +// ... 'formats': ('S1', 'i4', 'f4')}) +// array([(b'M', 21, 72.), (b'F', 35, 58.)], +// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") +// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) +// >>> x +// array([1., 3.]) +// >>> y +// array([2., 4.]) +// +// The `converters` argument is used to specify functions to preprocess the +// text prior to parsing. `converters` can be a dictionary that maps +// preprocessing functions to each column: +// +// >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n") +// >>> conv = { +// ... 0: lambda x: np.floor(float(x)), # conversion fn for column 0 +// ... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1 +// ... } +// >>> np.loadtxt(s, delimiter=",", converters=conv) +// array([[1., 3.], +// [3., 5.]]) +// +// `converters` can be a callable instead of a dictionary, in which case it +// is applied to all columns: +// +// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") +// >>> import functools +// >>> conv = functools.partial(int, base=16) +// >>> np.loadtxt(s, converters=conv) +// array([[222., 173.], +// [192., 222.]]) +// +// This example shows how `converters` can be used to convert a field +// with a trailing minus sign into a negative number. +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> def conv(fld): +// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) +// ... +// >>> np.loadtxt(s, converters=conv) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Using a callable as the converter can be particularly useful for handling +// values with different formatting, e.g. floats with underscores: +// +// >>> s = StringIO("1 2.7 100_000") +// >>> np.loadtxt(s, converters=float) +// array([1.e+00, 2.7e+00, 1.e+05]) +// +// This idea can be extended to automatically handle values specified in +// many different formats: +// +// >>> def conv(val): +// ... try: +// ... return float(val) +// ... except ValueError: +// ... return float.fromhex(val) +// >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2") +// >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None) +// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) +// +// Note that with the default ``encoding="bytes"``, the inputs to the +// converter function are latin-1 encoded byte strings. To deactivate the +// implicit encoding prior to conversion, use ``encoding=None`` +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x) +// >>> np.loadtxt(s, converters=conv, encoding=None) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Support for quoted fields is enabled with the `quotechar` parameter. +// Comment and delimiter characters are ignored when they appear within a +// quoted item delineated by `quotechar`: +// +// >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// dtype=[('label', '>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"') +// >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"') +// array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20") +// >>> np.loadtxt(d, usecols=(0, 1)) +// array([[ 1., 2.], +// [ 2., 4.], +// [ 3., 9.], +// [ 4., 16.]]) +// +// +// +//go:linkname Loadtxt py.loadtxt +func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object +// +// Load data from a text file, with missing values handled as specified. +// +// Each line past the first `skip_header` lines is split at the `delimiter` +// character, and characters following the `comments` character are discarded. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : dtype, optional +// Data type of the resulting array. +// If None, the dtypes will be determined by the contents of each +// column, individually. +// comments : str, optional +// The character used to indicate the start of a comment. +// All the characters occurring on a line after a comment are discarded. +// delimiter : str, int, or sequence, optional +// The string used to separate values. By default, any consecutive +// whitespaces act as delimiter. An integer or sequence of integers +// can also be provided as width(s) of each field. +// skiprows : int, optional +// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. +// skip_header : int, optional +// The number of lines to skip at the beginning of the file. +// skip_footer : int, optional +// The number of lines to skip at the end of the file. +// converters : variable, optional +// The set of functions that convert the data of a column to a value. +// The converters can also be used to provide a default value +// for missing data: ``converters = {3: lambda s: float(s or 0)}``. +// missing : variable, optional +// `missing` was removed in numpy 1.10. Please use `missing_values` +// instead. +// missing_values : variable, optional +// The set of strings corresponding to missing data. +// filling_values : variable, optional +// The set of values to be used as default when the data are missing. +// usecols : sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. +// names : {None, True, str, sequence}, optional +// If `names` is True, the field names are read from the first line after +// the first `skip_header` lines. This line can optionally be preceded +// by a comment delimiter. If `names` is a sequence or a single-string of +// comma-separated names, the names will be used to define the field names +// in a structured dtype. If `names` is None, the names of the dtype +// fields will be used, if any. +// excludelist : sequence, optional +// A list of names to exclude. This list is appended to the default list +// ['return','file','print']. Excluded names are appended with an +// underscore: for example, `file` would become `file_`. +// deletechars : str, optional +// A string combining invalid characters that must be deleted from the +// names. +// defaultfmt : str, optional +// A format used to define default field names, such as "f%i" or "f_%02i". +// autostrip : bool, optional +// Whether to automatically strip white spaces from the variables. +// replace_space : char, optional +// Character(s) used in replacement of white spaces in the variable +// names. By default, use a '_'. +// case_sensitive : {True, False, 'upper', 'lower'}, optional +// If True, field names are case sensitive. +// If False or 'upper', field names are converted to upper case. +// If 'lower', field names are converted to lower case. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = genfromtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// usemask : bool, optional +// If True, return a masked array. +// If False, return a regular array. +// loose : bool, optional +// If True, do not raise errors for invalid values. +// invalid_raise : bool, optional +// If True, an exception is raised if an inconsistency is detected in the +// number of columns. +// If False, a warning is emitted and the offending lines are skipped. +// max_rows : int, optional +// The maximum number of rows to read. Must not be used with skip_footer +// at the same time. If given, the value must be at least 1. Default is +// to read the entire file. +// +// .. versionadded:: 1.10.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply when `fname` is +// a file object. The special value 'bytes' enables backward compatibility +// workarounds that ensure that you receive byte arrays when possible +// and passes latin1 encoded strings to converters. Override this value to +// receive unicode arrays and pass strings as input to converters. If set +// to None the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// ndmin : int, optional +// Same parameter as `loadtxt` +// +// .. versionadded:: 1.23.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Data read from the text file. If `usemask` is True, this is a +// masked array. +// +// See Also +// -------- +// numpy.loadtxt : equivalent function when no data is missing. +// +// Notes +// ----- +// * When spaces are used as delimiters, or when no delimiter has been given +// as input, there should not be any missing data between two fields. +// * When the variables are named (either by a flexible dtype or with `names`), +// there must not be any header in the file (else a ValueError +// exception is raised). +// * Individual values are not stripped of spaces by default. +// When using a custom converter, make sure the function does remove spaces. +// +// References +// ---------- +// .. [1] NumPy User Guide, section `I/O with NumPy +// `_. +// +// Examples +// -------- +// >>> from io import StringIO +// >>> import numpy as np +// +// Comma delimited file with mixed dtype +// +// >>> s = StringIO(u"1,1.3,abcde") +// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), +// ... ('mystring','S5')], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only +// >>> data = np.genfromtxt(s, dtype=None, +// ... names = ['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) +// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", +// ... names=['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> s = StringIO(u"11.3abcde") +// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], +// ... delimiter=[1,3,5]) +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('intvar', '>> f = StringIO(''' +// ... text,# of chars +// ... hello world,11 +// ... numpy,5''') +// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') +// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], +// dtype=[('f0', 'S12'), ('f1', 'S12')]) +// +// +// +//go:linkname Genfromtxt py.genfromtxt +func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object +// +// Load ASCII data from a file and return it in a record array. +// +// If ``usemask=False`` a standard `recarray` is returned, +// if ``usemask=True`` a MaskedRecords array is returned. +// +// Parameters +// ---------- +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromtxt py.recfromtxt +func Recfromtxt(fname *py.Object) *py.Object +// +// Load ASCII data stored in a comma-separated file. +// +// The returned array is a record array (if ``usemask=False``, see +// `recarray`) or a masked record array (if ``usemask=True``, +// see `ma.mrecords.MaskedRecords`). +// +// Parameters +// ---------- +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function to load ASCII data. +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromcsv py.recfromcsv +func Recfromcsv(fname *py.Object) *py.Object +// +// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. +// +// .. warning:: Loading files that contain object arrays uses the ``pickle`` +// module, which is not secure against erroneous or maliciously +// constructed data. Consider passing ``allow_pickle=False`` to +// load data that is known not to contain object arrays for the +// safer handling of untrusted sources. +// +// Parameters +// ---------- +// file : file-like object, string, or pathlib.Path +// The file to read. File-like objects must support the +// ``seek()`` and ``read()`` methods and must always +// be opened in binary mode. Pickled files require that the +// file-like object support the ``readline()`` method as well. +// mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional +// If not None, then memory-map the file, using the given mode (see +// `numpy.memmap` for a detailed description of the modes). A +// memory-mapped array is kept on disk. However, it can be accessed +// and sliced like any ndarray. Memory mapping is especially useful +// for accessing small fragments of large files without reading the +// entire file into memory. +// allow_pickle : bool, optional +// Allow loading pickled object arrays stored in npy files. Reasons for +// disallowing pickles include security, as loading pickled data can +// execute arbitrary code. If pickles are disallowed, loading object +// arrays will fail. Default: False +// +// .. versionchanged:: 1.16.3 +// Made default False in response to CVE-2019-6446. +// +// fix_imports : bool, optional +// Only useful when loading Python 2 generated pickled files on Python 3, +// which includes npy/npz files containing object arrays. If `fix_imports` +// is True, pickle will try to map the old Python 2 names to the new names +// used in Python 3. +// encoding : str, optional +// What encoding to use when reading Python 2 strings. Only useful when +// loading Python 2 generated pickled files in Python 3, which includes +// npy/npz files containing object arrays. Values other than 'latin1', +// 'ASCII', and 'bytes' are not allowed, as they can corrupt numerical +// data. Default: 'ASCII' +// max_header_size : int, optional +// Maximum allowed size of the header. Large headers may not be safe +// to load securely and thus require explicitly passing a larger value. +// See :py:func:`ast.literal_eval()` for details. +// This option is ignored when `allow_pickle` is passed. In that case +// the file is by definition trusted and the limit is unnecessary. +// +// Returns +// ------- +// result : array, tuple, dict, etc. +// Data stored in the file. For ``.npz`` files, the returned instance +// of NpzFile class must be closed to avoid leaking file descriptors. +// +// Raises +// ------ +// OSError +// If the input file does not exist or cannot be read. +// UnpicklingError +// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. +// ValueError +// The file contains an object array, but ``allow_pickle=False`` given. +// EOFError +// When calling ``np.load`` multiple times on the same file handle, +// if all data has already been read +// +// See Also +// -------- +// save, savez, savez_compressed, loadtxt +// memmap : Create a memory-map to an array stored in a file on disk. +// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. +// +// Notes +// ----- +// - If the file contains pickle data, then whatever object is stored +// in the pickle is returned. +// - If the file is a ``.npy`` file, then a single array is returned. +// - If the file is a ``.npz`` file, then a dictionary-like object is +// returned, containing ``{filename: array}`` key-value pairs, one for +// each file in the archive. +// - If the file is a ``.npz`` file, the returned value supports the +// context manager protocol in a similar fashion to the open function:: +// +// with load('foo.npz') as data: +// a = data['a'] +// +// The underlying file descriptor is closed when exiting the 'with' +// block. +// +// Examples +// -------- +// Store data to disk, and load it again: +// +// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) +// >>> np.load('/tmp/123.npy') +// array([[1, 2, 3], +// [4, 5, 6]]) +// +// Store compressed data to disk, and load it again: +// +// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) +// >>> b=np.array([1, 2]) +// >>> np.savez('/tmp/123.npz', a=a, b=b) +// >>> data = np.load('/tmp/123.npz') +// >>> data['a'] +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> data['b'] +// array([1, 2]) +// >>> data.close() +// +// Mem-map the stored array, and then access the second row +// directly from disk: +// +// >>> X = np.load('/tmp/123.npy', mmap_mode='r') +// >>> X[1, :] +// memmap([4, 5, 6]) +// +// +// +//go:linkname Load py.load +func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object +// +// Build a matrix object from a string, nested sequence, or array. +// +// Parameters +// ---------- +// obj : str or array_like +// Input data. If a string, variables in the current scope may be +// referenced by name. +// ldict : dict, optional +// A dictionary that replaces local operands in current frame. +// Ignored if `obj` is not a string or `gdict` is None. +// gdict : dict, optional +// A dictionary that replaces global operands in current frame. +// Ignored if `obj` is not a string. +// +// Returns +// ------- +// out : matrix +// Returns a matrix object, which is a specialized 2-D array. +// +// See Also +// -------- +// block : +// A generalization of this function for N-d arrays, that returns normal +// ndarrays. +// +// Examples +// -------- +// >>> A = np.mat('1 1; 1 1') +// >>> B = np.mat('2 2; 2 2') +// >>> C = np.mat('3 4; 5 6') +// >>> D = np.mat('7 8; 9 0') +// +// All the following expressions construct the same block matrix: +// +// >>> np.bmat([[A, B], [C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat('A,B; C,D') +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// +// +// +//go:linkname Bmat py.bmat +func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. +// +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Mat py.mat +func Mat(data *py.Object, dtype *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. +// +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Asmatrix py.asmatrix +func Asmatrix(data *py.Object, dtype *py.Object) *py.Object +// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the absolute value element-wise. +// +// ``np.abs`` is a shorthand for this function. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// absolute : ndarray +// An ndarray containing the absolute value of +// each element in `x`. For complex input, ``a + ib``, the +// absolute value is :math:`\sqrt{ a^2 + b^2 }`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> x = np.array([-1.2, 1.2]) +// >>> np.absolute(x) +// array([ 1.2, 1.2]) +// >>> np.absolute(1.2 + 1j) +// 1.5620499351813308 +// +// Plot the function over ``[-10, 10]``: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(start=-10, stop=10, num=101) +// >>> plt.plot(x, np.absolute(x)) +// >>> plt.show() +// +// Plot the function over the complex plane: +// +// >>> xx = x + 1j * x[:, np.newaxis] +// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') +// >>> plt.show() +// +// The `abs` function can be used as a shorthand for ``np.absolute`` on +// ndarrays. +// +// >>> x = np.array([-1.2, 1.2]) +// >>> abs(x) +// array([1.2, 1.2]) +// +//go:linkname Abs py.abs +func Abs(__llgo_va_list ...interface{}) *py.Object diff --git a/numpy/numpy_autogen_link.go b/numpy/numpy_autogen_link.go new file mode 100644 index 00000000..bb5882ce --- /dev/null +++ b/numpy/numpy_autogen_link.go @@ -0,0 +1,5 @@ +package numpy + +import _ "github.com/goplus/lib/py" + +// LLGoPackage is defined in the main binding file From 25a986e3f532146a1a6083903bab24d130000e17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Thu, 14 Aug 2025 17:22:33 +0800 Subject: [PATCH 09/13] Add numpy package --- numpy_1/_demo/go.mod | 10 + numpy_1/_demo/go.sum | 2 + numpy_1/_demo/main.go | 11 + numpy_1/go.mod | 5 + numpy_1/go.sum | 2 + numpy_1/llpkg.cfg | 16 + numpy_1/llpyg.cfg | 155 + numpy_1/numpy.go | 9589 +++++++++++++++++++++++++++++++++ numpy_1/numpy_autogen_link.go | 5 + 9 files changed, 9795 insertions(+) create mode 100644 numpy_1/_demo/go.mod create mode 100644 numpy_1/_demo/go.sum create mode 100644 numpy_1/_demo/main.go create mode 100644 numpy_1/go.mod create mode 100644 numpy_1/go.sum create mode 100644 numpy_1/llpkg.cfg create mode 100644 numpy_1/llpyg.cfg create mode 100644 numpy_1/numpy.go create mode 100644 numpy_1/numpy_autogen_link.go diff --git a/numpy_1/_demo/go.mod b/numpy_1/_demo/go.mod new file mode 100644 index 00000000..46f5f92f --- /dev/null +++ b/numpy_1/_demo/go.mod @@ -0,0 +1,10 @@ +module test_math3 + +go 1.24.5 + +replace github.com/goplus/llpkg/math => ../ + +require ( + github.com/goplus/lib v0.2.0 + github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 +) diff --git a/numpy_1/_demo/go.sum b/numpy_1/_demo/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/numpy_1/_demo/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy_1/_demo/main.go b/numpy_1/_demo/main.go new file mode 100644 index 00000000..c34d0173 --- /dev/null +++ b/numpy_1/_demo/main.go @@ -0,0 +1,11 @@ +package main + +import ( + "github.com/goplus/lib/py" +) + +func main() { + // 初始化 Python + py.Initialize() + defer py.Finalize() +} diff --git a/numpy_1/go.mod b/numpy_1/go.mod new file mode 100644 index 00000000..82bc5445 --- /dev/null +++ b/numpy_1/go.mod @@ -0,0 +1,5 @@ +module github.com/goplus/llpkg/numpy + +go 1.23 + +require github.com/goplus/lib v0.2.0 diff --git a/numpy_1/go.sum b/numpy_1/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/numpy_1/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy_1/llpkg.cfg b/numpy_1/llpkg.cfg new file mode 100644 index 00000000..8356bfc2 --- /dev/null +++ b/numpy_1/llpkg.cfg @@ -0,0 +1,16 @@ +{ + "type": "python", + "upstream": { + "installer": { + "name": "pip", + "config": { + "python_version": "3.12", + "index_url": "https://pypi.org/simple/" + } + }, + "package": { + "name": "numpy", + "version": "builtin" + } + } +} \ No newline at end of file diff --git a/numpy_1/llpyg.cfg b/numpy_1/llpyg.cfg new file mode 100644 index 00000000..b8888a8d --- /dev/null +++ b/numpy_1/llpyg.cfg @@ -0,0 +1,155 @@ +{ + "name": "numpy", + "module": "numpy", + "python": true, + "symMap": { + "abs": "Abs", + "absolute": "Absolute", + "add": "Add", + "all": "All", + "any": "Any", + "arange": "Arange", + "arccos": "Arccos", + "arccosh": "Arccosh", + "arcsin": "Arcsin", + "arcsinh": "Arcsinh", + "arctan": "Arctan", + "arctanh": "Arctanh", + "array": "Array", + "average": "Average", + "bin": "Bin", + "bool": "Bool", + "c_": "C", + "ceil": "Ceil", + "chr": "Chr", + "corrcoef": "Corrcoef", + "cos": "Cos", + "cosh": "Cosh", + "cov": "Cov", + "cross": "Cross", + "diag": "Diag", + "dict": "Dict", + "dir": "Dir", + "divide": "Divide", + "dot": "Dot", + "einsum": "Einsum", + "empty": "Empty", + "enumerate": "Enumerate", + "exp": "Exp", + "eye": "Eye", + "fabs": "Fabs", + "fft": "Fft", + "filter": "Filter", + "float": "Float", + "floor": "Floor", + "format": "Format", + "frozenset": "FrozenSet", + "getattr": "GetAttr", + "hasattr": "HasAttr", + "hash": "Hash", + "help": "Help", + "hex": "Hex", + "id": "ID", + "identity": "Identity", + "inner": "Inner", + "input": "Input", + "int": "Int", + "isinstance": "IsInstance", + "issubclass": "IsSubclass", + "iter": "Iter", + "len": "Len", + "linalg": "Linalg", + "linspace": "Linspace", + "list": "List", + "locals": "Locals", + "log": "Log", + "log10": "Log10", + "log2": "Log2", + "logspace": "Logspace", + "map": "Map", + "matmul": "Matmul", + "max": "Max", + "mean": "Mean", + "median": "Median", + "meshgrid": "Meshgrid", + "mgrid": "Mgrid", + "min": "Min", + "mod": "Mod", + "multiply": "Multiply", + "next": "Next", + "oct": "Oct", + "ogrid": "Ogrid", + "ones": "Ones", + "open": "Open", + "ord": "Ord", + "outer": "Outer", + "percentile": "Percentile", + "pow": "Pow", + "power": "Power", + "print": "Print", + "prod": "Prod", + "ptp": "Ptp", + "quantile": "Quantile", + "r_": "R", + "random": "Random", + "range": "Range", + "remainder": "Remainder", + "repr": "Repr", + "reversed": "Reversed", + "rint": "Rint", + "round": "Round", + "set": "Set", + "setattr": "SetAttr", + "sign": "Sign", + "sin": "Sin", + "sinh": "Sinh", + "sorted": "Sorted", + "sqrt": "Sqrt", + "std": "Std", + "str": "Str", + "subtract": "Subtract", + "sum": "Sum", + "tan": "Tan", + "tanh": "Tanh", + "tensordot": "Tensordot", + "tri": "Tri", + "tril": "Tril", + "triu": "Triu", + "trunc": "Trunc", + "tuple": "Tuple", + "type": "Type", + "vander": "Vander", + "var": "Var", + "vars": "Vars", + "zeros": "Zeros", + "zip": "Zip" + }, + "deps": [ + "py" + ], + "include": [ + "numpy" + ], + "exclude": [ + "__builtins__", + "__cached__", + "__doc__", + "__file__", + "__loader__", + "__name__", + "__package__", + "__spec__" + ], + "constants": { + "bool_": "Bool", + "e": "E", + "float32": "Float32", + "float64": "Float64", + "inf": "Inf", + "int32": "Int32", + "int64": "Int64", + "nan": "NaN", + "pi": "Pi", + "uint8": "Uint8" + } +} \ No newline at end of file diff --git a/numpy_1/numpy.go b/numpy_1/numpy.go new file mode 100644 index 00000000..a8146d45 --- /dev/null +++ b/numpy_1/numpy.go @@ -0,0 +1,9589 @@ +package numpy + +import ( + "github.com/goplus/lib/py" + _ "unsafe" +) + +const LLGoPackage = "py.numpy" +// +// Show libraries and system information on which NumPy was built +// and is being used +// +// Parameters +// ---------- +// mode : {`'stdout'`, `'dicts'`}, optional. +// Indicates how to display the config information. +// `'stdout'` prints to console, `'dicts'` returns a dictionary +// of the configuration. +// +// Returns +// ------- +// out : {`dict`, `None`} +// If mode is `'dicts'`, a dict is returned, else None +// +// See Also +// -------- +// get_include : Returns the directory containing NumPy C +// header files. +// +// Notes +// ----- +// 1. The `'stdout'` mode will give more readable +// output if ``pyyaml`` is installed +// +// +// +//go:linkname ShowConfig py.show_config +func ShowConfig(mode *py.Object) *py.Object +// +// Check 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. +// +// Parameters +// ---------- +// a : ndarray +// Input array. +// +// Returns +// ------- +// isfortran : bool +// Returns True if the array is Fortran contiguous but *not* C contiguous. +// +// +// Examples +// -------- +// +// np.array allows to specify whether the array is written in C-contiguous +// order (last index varies the fastest), or FORTRAN-contiguous order in +// memory (first index varies the fastest). +// +// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') +// >>> a +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(a) +// False +// +// >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') +// >>> b +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(b) +// True +// +// +// The transpose of a C-ordered array is a FORTRAN-ordered array. +// +// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') +// >>> a +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(a) +// False +// >>> b = a.T +// >>> b +// array([[1, 4], +// [2, 5], +// [3, 6]]) +// >>> np.isfortran(b) +// True +// +// C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. +// +// >>> np.isfortran(np.array([1, 2], order='F')) +// False +// +// +// +//go:linkname Isfortran py.isfortran +func Isfortran(a *py.Object) *py.Object +// +// Return an array representing the indices of a grid. +// +// Compute an array where the subarrays contain index values 0, 1, ... +// varying only along the corresponding axis. +// +// Parameters +// ---------- +// dimensions : sequence of ints +// The shape of the grid. +// dtype : dtype, optional +// Data type of the result. +// sparse : boolean, optional +// Return a sparse representation of the grid instead of a dense +// representation. Default is False. +// +// .. versionadded:: 1.17 +// +// Returns +// ------- +// grid : one ndarray or tuple of ndarrays +// If sparse is False: +// Returns one array of grid indices, +// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. +// If sparse is True: +// Returns a tuple of arrays, with +// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with +// dimensions[i] in the ith place +// +// See Also +// -------- +// mgrid, ogrid, meshgrid +// +// Notes +// ----- +// The output shape in the dense case is obtained by prepending the number +// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` +// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is +// ``(N, r0, ..., rN-1)``. +// +// The subarrays ``grid[k]`` contains the N-D array of indices along the +// ``k-th`` axis. Explicitly:: +// +// grid[k, i0, i1, ..., iN-1] = ik +// +// Examples +// -------- +// >>> grid = np.indices((2, 3)) +// >>> grid.shape +// (2, 2, 3) +// >>> grid[0] # row indices +// array([[0, 0, 0], +// [1, 1, 1]]) +// >>> grid[1] # column indices +// array([[0, 1, 2], +// [0, 1, 2]]) +// +// The indices can be used as an index into an array. +// +// >>> x = np.arange(20).reshape(5, 4) +// >>> row, col = np.indices((2, 3)) +// >>> x[row, col] +// array([[0, 1, 2], +// [4, 5, 6]]) +// +// Note that it would be more straightforward in the above example to +// extract the required elements directly with ``x[:2, :3]``. +// +// If sparse is set to true, the grid will be returned in a sparse +// representation. +// +// >>> i, j = np.indices((2, 3), sparse=True) +// >>> i.shape +// (2, 1) +// >>> j.shape +// (1, 3) +// >>> i # row indices +// array([[0], +// [1]]) +// >>> j # column indices +// array([[0, 1, 2]]) +// +// +// +//go:linkname Indices py.indices +func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object +// +// Construct an array by executing a function over each coordinate. +// +// The resulting array therefore has a value ``fn(x, y, z)`` at +// coordinate ``(x, y, z)``. +// +// Parameters +// ---------- +// function : callable +// The function is called with N parameters, where N is the rank of +// `shape`. Each parameter represents the coordinates of the array +// varying along a specific axis. For example, if `shape` +// were ``(2, 2)``, then the parameters would be +// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` +// shape : (N,) tuple of ints +// Shape of the output array, which also determines the shape of +// the coordinate arrays passed to `function`. +// dtype : data-type, optional +// Data-type of the coordinate arrays passed to `function`. +// By default, `dtype` is float. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// fromfunction : any +// The result of the call to `function` is passed back directly. +// Therefore the shape of `fromfunction` is completely determined by +// `function`. If `function` returns a scalar value, the shape of +// `fromfunction` would not match the `shape` parameter. +// +// See Also +// -------- +// indices, meshgrid +// +// Notes +// ----- +// Keywords other than `dtype` and `like` are passed to `function`. +// +// Examples +// -------- +// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) +// array([[0., 0.], +// [1., 1.]]) +// +// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) +// array([[0., 1.], +// [0., 1.]]) +// +// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) +// array([[ True, False, False], +// [False, True, False], +// [False, False, True]]) +// +// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) +// array([[0, 1, 2], +// [1, 2, 3], +// [2, 3, 4]]) +// +// +// +//go:linkname Fromfunction py.fromfunction +func Fromfunction(function *py.Object, shape *py.Object) *py.Object +// +// Returns True if the type of `element` is a scalar type. +// +// Parameters +// ---------- +// element : any +// Input argument, can be of any type and shape. +// +// Returns +// ------- +// val : bool +// True if `element` is a scalar type, False if it is not. +// +// See Also +// -------- +// ndim : Get the number of dimensions of an array +// +// Notes +// ----- +// If you need a stricter way to identify a *numerical* scalar, use +// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most +// non-numerical elements such as strings. +// +// In most 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: +// +// +--------------------------------------+---------------+-------------------+ +// | x |``isscalar(x)``|``np.ndim(x) == 0``| +// +======================================+===============+===================+ +// | PEP 3141 numeric objects (including | ``True`` | ``True`` | +// | builtins) | | | +// +--------------------------------------+---------------+-------------------+ +// | builtin string and buffer objects | ``True`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other builtin objects, like | ``False`` | ``True`` | +// | `pathlib.Path`, `Exception`, | | | +// | the result of `re.compile` | | | +// +--------------------------------------+---------------+-------------------+ +// | third-party objects like | ``False`` | ``True`` | +// | `matplotlib.figure.Figure` | | | +// +--------------------------------------+---------------+-------------------+ +// | zero-dimensional numpy arrays | ``False`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other numpy arrays | ``False`` | ``False`` | +// +--------------------------------------+---------------+-------------------+ +// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | +// | objects | | | +// +--------------------------------------+---------------+-------------------+ +// +// Examples +// -------- +// >>> np.isscalar(3.1) +// True +// >>> np.isscalar(np.array(3.1)) +// False +// >>> np.isscalar([3.1]) +// False +// >>> np.isscalar(False) +// True +// >>> np.isscalar('numpy') +// True +// +// NumPy supports PEP 3141 numbers: +// +// >>> from fractions import Fraction +// >>> np.isscalar(Fraction(5, 17)) +// True +// >>> from numbers import Number +// >>> np.isscalar(Number()) +// True +// +// +// +//go:linkname Isscalar py.isscalar +func Isscalar(element *py.Object) *py.Object +// +// Return the binary representation of the input number as a string. +// +// For negative numbers, if width is not given, a minus sign is added to the +// front. If width is given, the two's complement of the number is +// returned, with respect to that width. +// +// In a two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit two's-complement +// system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// num : int +// Only an integer decimal number can be used. +// width : int, optional +// The length of the returned string if `num` is positive, or the length +// of the two's complement if `num` is negative, provided that `width` is +// at least a sufficient number of bits for `num` to be represented in the +// designated form. +// +// If the `width` value is insufficient, it will be ignored, and `num` will +// be returned in binary (`num` > 0) or two's complement (`num` < 0) form +// with its width equal to the minimum number of bits needed to represent +// the number in the designated form. This behavior is deprecated and will +// later raise an error. +// +// .. deprecated:: 1.12.0 +// +// Returns +// ------- +// bin : str +// Binary representation of `num` or two's complement of `num`. +// +// See Also +// -------- +// base_repr: Return a string representation of a number in the given base +// system. +// bin: Python's built-in binary representation generator of an integer. +// +// Notes +// ----- +// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x +// faster. +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// >>> np.binary_repr(3) +// '11' +// >>> np.binary_repr(-3) +// '-11' +// >>> np.binary_repr(3, width=4) +// '0011' +// +// The two's complement is returned when the input number is negative and +// width is specified: +// +// >>> np.binary_repr(-3, width=3) +// '101' +// >>> np.binary_repr(-3, width=5) +// '11101' +// +// +// +//go:linkname BinaryRepr py.binary_repr +func BinaryRepr(num *py.Object, width *py.Object) *py.Object +// +// Return a string representation of a number in the given base system. +// +// Parameters +// ---------- +// number : int +// The value to convert. Positive and negative values are handled. +// base : int, optional +// Convert `number` to the `base` number system. The valid range is 2-36, +// the default value is 2. +// padding : int, optional +// Number of zeros padded on the left. Default is 0 (no padding). +// +// Returns +// ------- +// out : str +// String representation of `number` in `base` system. +// +// See Also +// -------- +// binary_repr : Faster version of `base_repr` for base 2. +// +// Examples +// -------- +// >>> np.base_repr(5) +// '101' +// >>> np.base_repr(6, 5) +// '11' +// >>> np.base_repr(7, base=5, padding=3) +// '00012' +// +// >>> np.base_repr(10, base=16) +// 'A' +// >>> np.base_repr(32, base=16) +// '20' +// +// +// +//go:linkname BaseRepr py.base_repr +func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object +// +// Return a new array of given shape and type, filled with ones. +// +// Parameters +// ---------- +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// dtype : data-type, optional +// The desired data-type for the array, e.g., `numpy.int8`. Default is +// `numpy.float64`. +// order : {'C', 'F'}, optional, default: C +// Whether to store multi-dimensional data in row-major +// (C-style) or column-major (Fortran-style) order in +// memory. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of ones with the given shape, dtype, and order. +// +// See Also +// -------- +// ones_like : Return an array of ones with shape and type of input. +// empty : Return a new uninitialized array. +// zeros : Return a new array setting values to zero. +// full : Return a new array of given shape filled with value. +// +// +// Examples +// -------- +// >>> np.ones(5) +// array([1., 1., 1., 1., 1.]) +// +// >>> np.ones((5,), dtype=int) +// array([1, 1, 1, 1, 1]) +// +// >>> np.ones((2, 1)) +// array([[1.], +// [1.]]) +// +// >>> s = (2,2) +// >>> np.ones(s) +// array([[1., 1.], +// [1., 1.]]) +// +// +// +//go:linkname Ones py.ones +func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// Return the identity array. +// +// The identity array is a square array with ones on +// the main diagonal. +// +// Parameters +// ---------- +// n : int +// Number of rows (and columns) in `n` x `n` output. +// dtype : data-type, optional +// Data-type of the output. Defaults to ``float``. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// `n` x `n` array with its main diagonal set to one, +// and all other elements 0. +// +// Examples +// -------- +// >>> np.identity(3) +// array([[1., 0., 0.], +// [0., 1., 0.], +// [0., 0., 1.]]) +// +// +// +//go:linkname Identity py.identity +func Identity(n *py.Object, dtype *py.Object) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. +// +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: +// +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' +// +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) +// +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) +// +//go:linkname BitwiseNot py.bitwise_not +func BitwiseNot(__llgo_va_list ...interface{}) *py.Object +// +// Return a new array of given shape and type, filled with `fill_value`. +// +// Parameters +// ---------- +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// fill_value : scalar or array_like +// Fill value. +// dtype : data-type, optional +// The desired data-type for the array The default, None, means +// ``np.array(fill_value).dtype``. +// order : {'C', 'F'}, optional +// Whether to store multidimensional data in C- or Fortran-contiguous +// (row- or column-wise) order in memory. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of `fill_value` with the given shape, dtype, and order. +// +// See Also +// -------- +// full_like : Return a new array with shape of input filled with value. +// empty : Return a new uninitialized array. +// ones : Return a new array setting values to one. +// zeros : Return a new array setting values to zero. +// +// Examples +// -------- +// >>> np.full((2, 2), np.inf) +// array([[inf, inf], +// [inf, inf]]) +// >>> np.full((2, 2), 10) +// array([[10, 10], +// [10, 10]]) +// +// >>> np.full((2, 2), [1, 2]) +// array([[1, 2], +// [1, 2]]) +// +// +// +//go:linkname Full py.full +func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object +// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) +// +// Matrix product of two arrays. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays, scalars not allowed. +// out : ndarray, optional +// A location into which the result is stored. If provided, it must have +// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not +// provided or None, a freshly-allocated array is returned. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// .. versionadded:: 1.16 +// Now handles ufunc kwargs +// +// Returns +// ------- +// y : ndarray +// The matrix product of the inputs. +// This is a scalar only when both x1, x2 are 1-d vectors. +// +// Raises +// ------ +// ValueError +// If the last dimension of `x1` is not the same size as +// the second-to-last dimension of `x2`. +// +// If a scalar value is passed in. +// +// See Also +// -------- +// vdot : Complex-conjugating dot product. +// tensordot : Sum products over arbitrary axes. +// einsum : Einstein summation convention. +// dot : alternative matrix product with different broadcasting rules. +// +// Notes +// ----- +// +// The behavior depends on the arguments in the following way. +// +// - If both arguments are 2-D they are multiplied like conventional +// matrices. +// - If either argument is N-D, N > 2, it is treated as a stack of +// matrices residing in the last two indexes and broadcast accordingly. +// - If the first argument is 1-D, it is promoted to a matrix by +// prepending a 1 to its dimensions. After matrix multiplication +// the prepended 1 is removed. +// - If the second argument is 1-D, it is promoted to a matrix by +// appending a 1 to its dimensions. After matrix multiplication +// the appended 1 is removed. +// +// ``matmul`` differs from ``dot`` in two important ways: +// +// - Multiplication by scalars is not allowed, use ``*`` instead. +// - Stacks of matrices are broadcast together as if the matrices +// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: +// +// >>> a = np.ones([9, 5, 7, 4]) +// >>> c = np.ones([9, 5, 4, 3]) +// >>> np.dot(a, c).shape +// (9, 5, 7, 9, 5, 3) +// >>> np.matmul(a, c).shape +// (9, 5, 7, 3) +// >>> # n is 7, k is 4, m is 3 +// +// The matmul function implements the semantics of the ``@`` operator +// introduced in Python 3.5 following :pep:`465`. +// +// It uses an optimized BLAS library when possible (see `numpy.linalg`). +// +// Examples +// -------- +// For 2-D arrays it is the matrix product: +// +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([[4, 1], +// ... [2, 2]]) +// >>> np.matmul(a, b) +// array([[4, 1], +// [2, 2]]) +// +// For 2-D mixed with 1-D, the result is the usual. +// +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([1, 2]) +// >>> np.matmul(a, b) +// array([1, 2]) +// >>> np.matmul(b, a) +// array([1, 2]) +// +// +// Broadcasting is conventional for stacks of arrays +// +// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) +// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) +// >>> np.matmul(a,b).shape +// (2, 2, 2) +// >>> np.matmul(a, b)[0, 1, 1] +// 98 +// >>> sum(a[0, 1, :] * b[0 , :, 1]) +// 98 +// +// Vector, vector returns the scalar inner product, but neither argument +// is complex-conjugated: +// +// >>> np.matmul([2j, 3j], [2j, 3j]) +// (-13+0j) +// +// Scalar multiplication raises an error. +// +// >>> np.matmul([1,2], 3) +// Traceback (most recent call last): +// ... +// ValueError: matmul: Input operand 1 does not have enough dimensions ... +// +// The ``@`` operator can be used as a shorthand for ``np.matmul`` on +// ndarrays. +// +// >>> x1 = np.array([2j, 3j]) +// >>> x2 = np.array([2j, 3j]) +// >>> x1 @ x2 +// (-13+0j) +// +// .. versionadded:: 1.10.0 +// +//go:linkname Matmul py.matmul +func Matmul(__llgo_va_list ...interface{}) *py.Object +// arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric inverse cosine, element-wise. +// +// The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``. +// +// Parameters +// ---------- +// x : array_like +// `x`-coordinate on the unit circle. +// For real arguments, the domain is [-1, 1]. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// The angle of the ray intersecting the unit circle at the given +// `x`-coordinate in radians [0, pi]. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// cos, arctan, arcsin, emath.arccos +// +// Notes +// ----- +// `arccos` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``cos(z) = x``. The convention is to return +// the angle `z` whose real part lies in `[0, pi]`. +// +// For real-valued input data types, `arccos` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse `cos` is also known as `acos` or cos^-1. +// +// References +// ---------- +// M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// We expect the arccos of 1 to be 0, and of -1 to be pi: +// +// >>> np.arccos([1, -1]) +// array([ 0. , 3.14159265]) +// +// Plot arccos: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-1, 1, num=100) +// >>> plt.plot(x, np.arccos(x)) +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Arccos py.arccos +func Arccos(__llgo_va_list ...interface{}) *py.Object +// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic cosine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// arccosh : ndarray +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// +// cosh, arcsinh, sinh, arctanh, tanh +// +// Notes +// ----- +// `arccosh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `cosh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in +// ``[0, inf]``. +// +// For real-valued input data types, `arccosh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `arccosh` is a complex analytical function that +// has a branch cut `[-inf, 1]` and is continuous from above on it. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arccosh +// +// Examples +// -------- +// >>> np.arccosh([np.e, 10.0]) +// array([ 1.65745445, 2.99322285]) +// >>> np.arccosh(1) +// 0.0 +// +//go:linkname Arccosh py.arccosh +func Arccosh(__llgo_va_list ...interface{}) *py.Object +// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse sine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// `y`-coordinate on the unit circle. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// The inverse sine of each element in `x`, in radians and in the +// closed interval ``[-pi/2, pi/2]``. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin +// +// Notes +// ----- +// `arcsin` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that :math:`sin(z) = x`. The convention is to +// return the angle `z` whose real part lies in [-pi/2, pi/2]. +// +// For real-valued input data types, *arcsin* always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse sine is also known as `asin` or sin^{-1}. +// +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79ff. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// >>> np.arcsin(1) # pi/2 +// 1.5707963267948966 +// >>> np.arcsin(-1) # -pi/2 +// -1.5707963267948966 +// >>> np.arcsin(0) +// 0.0 +// +//go:linkname Arcsin py.arcsin +func Arcsin(__llgo_va_list ...interface{}) *py.Object +// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic sine element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `arcsinh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `sinh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// +// For real-valued input data types, `arcsinh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// returns ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arcsinh +// +// Examples +// -------- +// >>> np.arcsinh(np.array([np.e, 10.0])) +// array([ 1.72538256, 2.99822295]) +// +//go:linkname Arcsinh py.arcsinh +func Arcsinh(__llgo_va_list ...interface{}) *py.Object +// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric inverse tangent, element-wise. +// +// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. +// +// Parameters +// ---------- +// x : array_like +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Out has the same shape as `x`. Its real part is in +// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) +// and the positive `x`-axis. +// angle : Argument of complex values. +// +// Notes +// ----- +// `arctan` is a multi-valued function: for each `x` there are infinitely +// many numbers `z` such that tan(`z`) = `x`. The convention is to return +// the angle `z` whose real part lies in [-pi/2, pi/2]. +// +// For real-valued input data types, `arctan` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse tangent is also known as `atan` or tan^{-1}. +// +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// We expect the arctan of 0 to be 0, and of 1 to be pi/4: +// +// >>> np.arctan([0, 1]) +// array([ 0. , 0.78539816]) +// +// >>> np.pi/4 +// 0.78539816339744828 +// +// Plot arctan: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-10, 10) +// >>> plt.plot(x, np.arctan(x)) +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Arctan py.arctan +func Arctan(__llgo_va_list ...interface{}) *py.Object +// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. +// +// 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`). (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). +// +// This function is not defined for complex-valued arguments; for the +// so-called argument of complex values, use `angle`. +// +// Parameters +// ---------- +// x1 : array_like, real-valued +// `y`-coordinates. +// x2 : array_like, real-valued +// `x`-coordinates. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// Array of angles in radians, in the range ``[-pi, pi]``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// arctan, tan, angle +// +// Notes +// ----- +// *arctan2* is identical to the `atan2` function of the underlying +// C library. The following special values are defined in the C +// standard: [1]_ +// +// ====== ====== ================ +// `x1` `x2` `arctan2(x1,x2)` +// ====== ====== ================ +// +/- 0 +0 +/- 0 +// +/- 0 -0 +/- pi +// > 0 +/-inf +0 / +pi +// < 0 +/-inf -0 / -pi +// +/-inf +inf +/- (pi/4) +// +/-inf -inf +/- (3*pi/4) +// ====== ====== ================ +// +// Note that +0 and -0 are distinct floating point numbers, as are +inf +// and -inf. +// +// References +// ---------- +// .. [1] ISO/IEC standard 9899:1999, "Programming language C." +// +// Examples +// -------- +// Consider four points in different quadrants: +// +// >>> x = np.array([-1, +1, +1, -1]) +// >>> y = np.array([-1, -1, +1, +1]) +// >>> np.arctan2(y, x) * 180 / np.pi +// array([-135., -45., 45., 135.]) +// +// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 +// and at several other special points, obtaining values in +// the range ``[-pi, pi]``: +// +// >>> np.arctan2([1., -1.], [0., 0.]) +// array([ 1.57079633, -1.57079633]) +// >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) +// array([0. , 3.14159265, 0.78539816]) +// +//go:linkname Arctan2 py.arctan2 +func Arctan2(__llgo_va_list ...interface{}) *py.Object +// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic tangent element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.arctanh +// +// Notes +// ----- +// `arctanh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``tanh(z) = x``. The convention is to return +// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// +// For real-valued input data types, `arctanh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arctanh +// +// Examples +// -------- +// >>> np.arctanh([0, -0.5]) +// array([ 0. , -0.54930614]) +// +//go:linkname Arctanh py.arctanh +func Arctanh(__llgo_va_list ...interface{}) *py.Object +// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise AND of two arrays element-wise. +// +// Computes the bit-wise AND of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``&``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and +// bitwise_or +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise AND of 13 and 17 is +// therefore ``000000001``, or 1: +// +// >>> np.bitwise_and(13, 17) +// 1 +// +// >>> np.bitwise_and(14, 13) +// 12 +// >>> np.binary_repr(12) +// '1100' +// >>> np.bitwise_and([14,3], 13) +// array([12, 1]) +// +// >>> np.bitwise_and([11,7], [4,25]) +// array([0, 1]) +// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) +// array([ 2, 4, 16]) +// >>> np.bitwise_and([True, True], [False, True]) +// array([False, True]) +// +// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([3, 14, 16]) +// >>> x1 & x2 +// array([ 2, 4, 16]) +// +//go:linkname BitwiseAnd py.bitwise_and +func BitwiseAnd(__llgo_va_list ...interface{}) *py.Object +// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise OR of two arrays element-wise. +// +// Computes the bit-wise OR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``|``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or +// bitwise_and +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 has the binary representation ``00001101``. Likewise, +// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is +// then ``00011101``, or 29: +// +// >>> np.bitwise_or(13, 16) +// 29 +// >>> np.binary_repr(29) +// '11101' +// +// >>> np.bitwise_or(32, 2) +// 34 +// >>> np.bitwise_or([33, 4], 1) +// array([33, 5]) +// >>> np.bitwise_or([33, 4], [1, 2]) +// array([33, 6]) +// +// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) +// array([ 6, 5, 255]) +// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) +// array([ 6, 5, 255]) +// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), +// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) +// array([ 6, 5, 255, 2147483647]) +// >>> np.bitwise_or([True, True], [False, True]) +// array([ True, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([4, 4, 4]) +// >>> x1 | x2 +// array([ 6, 5, 255]) +// +//go:linkname BitwiseOr py.bitwise_or +func BitwiseOr(__llgo_va_list ...interface{}) *py.Object +// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise XOR of two arrays element-wise. +// +// Computes the bit-wise XOR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``^``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_xor +// bitwise_and +// bitwise_or +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise XOR of 13 and 17 is +// therefore ``00011100``, or 28: +// +// >>> np.bitwise_xor(13, 17) +// 28 +// >>> np.binary_repr(28) +// '11100' +// +// >>> np.bitwise_xor(31, 5) +// 26 +// >>> np.bitwise_xor([31,3], 5) +// array([26, 6]) +// +// >>> np.bitwise_xor([31,3], [5,6]) +// array([26, 5]) +// >>> np.bitwise_xor([True, True], [False, True]) +// array([ True, False]) +// +// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on +// ndarrays. +// +// >>> x1 = np.array([True, True]) +// >>> x2 = np.array([False, True]) +// >>> x1 ^ x2 +// array([ True, False]) +// +//go:linkname BitwiseXor py.bitwise_xor +func BitwiseXor(__llgo_va_list ...interface{}) *py.Object +// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the cube-root of an array, element-wise. +// +// .. versionadded:: 1.10.0 +// +// Parameters +// ---------- +// x : array_like +// The values whose cube-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the cube +// cube-root of each element in `x`. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. +// +// +// Examples +// -------- +// >>> np.cbrt([1,8,27]) +// array([ 1., 2., 3.]) +// +//go:linkname Cbrt py.cbrt +func Cbrt(__llgo_va_list ...interface{}) *py.Object +// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the ceiling of the input, element-wise. +// +// The ceil of the scalar `x` is the smallest integer `i`, such that +// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The ceiling of each element in `x`, with `float` dtype. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// floor, trunc, rint, fix +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.ceil(a) +// array([-1., -1., -0., 1., 2., 2., 2.]) +// +//go:linkname Ceil py.ceil +func Ceil(__llgo_va_list ...interface{}) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conj py.conj +func Conj(__llgo_va_list ...interface{}) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conjugate py.conjugate +func Conjugate(__llgo_va_list ...interface{}) *py.Object +// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Change the sign of x1 to that of x2, element-wise. +// +// If `x2` is a scalar, its sign will be copied to all elements of `x1`. +// +// Parameters +// ---------- +// x1 : array_like +// Values to change the sign of. +// x2 : array_like +// The sign of `x2` is copied to `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The values of `x1` with the sign of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.copysign(1.3, -1) +// -1.3 +// >>> 1/np.copysign(0, 1) +// inf +// >>> 1/np.copysign(0, -1) +// -inf +// +// >>> np.copysign([-1, 0, 1], -1.1) +// array([-1., -0., -1.]) +// >>> np.copysign([-1, 0, 1], np.arange(3)-1) +// array([-1., 0., 1.]) +// +//go:linkname Copysign py.copysign +func Copysign(__llgo_va_list ...interface{}) *py.Object +// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Cosine element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding cosine values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. +// +// Examples +// -------- +// >>> np.cos(np.array([0, np.pi/2, np.pi])) +// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) +// >>> +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Cos py.cos +func Cos(__llgo_va_list ...interface{}) *py.Object +// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Hyperbolic cosine, element-wise. +// +// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array of same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.cosh(0) +// 1.0 +// +// The hyperbolic cosine describes the shape of a hanging cable: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-4, 4, 1000) +// >>> plt.plot(x, np.cosh(x)) +// >>> plt.show() +// +//go:linkname Cosh py.cosh +func Cosh(__llgo_va_list ...interface{}) *py.Object +// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Angles in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in radians. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : Convert angles from radians to degrees. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// ``deg2rad(x)`` is ``x * pi / 180``. +// +// Examples +// -------- +// >>> np.deg2rad(180) +// 3.1415926535897931 +// +//go:linkname Deg2rad py.deg2rad +func Deg2rad(__llgo_va_list ...interface{}) *py.Object +// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. +// +// Parameters +// ---------- +// x : array_like +// Input array in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray of floats +// The corresponding degree values; if `out` was supplied this is a +// reference to it. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : equivalent function +// +// Examples +// -------- +// Convert a radian array to degrees +// +// >>> rad = np.arange(12.)*np.pi/6 +// >>> np.degrees(rad) +// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., +// 270., 300., 330.]) +// +// >>> out = np.zeros((rad.shape)) +// >>> r = np.degrees(rad, out) +// >>> np.all(r == out) +// True +// +//go:linkname Degrees py.degrees +func Degrees(__llgo_va_list ...interface{}) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. +// +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. +// +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.divide(x1, x2) +// array([[nan, 1. , 1. ], +// [inf, 4. , 2.5], +// [inf, 7. , 4. ]]) +// +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) +// +//go:linkname Divide py.divide +func Divide(__llgo_va_list ...interface{}) *py.Object +// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return element-wise quotient and remainder simultaneously. +// +// .. versionadded:: 1.13.0 +// +// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster +// because it avoids redundant work. It is used to implement the Python +// built-in function ``divmod`` on NumPy arrays. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out1 : ndarray +// Element-wise quotient resulting from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// out2 : ndarray +// Element-wise remainder from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent to Python's ``//`` operator. +// remainder : Equivalent to Python's ``%`` operator. +// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return +// values switched. +// +// Examples +// -------- +// >>> np.divmod(np.arange(5), 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// +// The `divmod` function can be used as a shorthand for ``np.divmod`` on +// ndarrays. +// +// >>> x = np.arange(5) +// >>> divmod(x, 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// +//go:linkname Divmod py.divmod +func Divmod(__llgo_va_list ...interface{}) *py.Object +// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return (x1 == x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// not_equal, greater_equal, less_equal, greater, less +// +// Examples +// -------- +// >>> np.equal([0, 1, 3], np.arange(3)) +// array([ True, True, False]) +// +// What is compared are values, not types. So an int (1) and an array of +// length one can evaluate as True: +// +// >>> np.equal(1, np.ones(1)) +// array([ True]) +// +// The ``==`` operator can be used as a shorthand for ``np.equal`` on +// ndarrays. +// +// >>> a = np.array([2, 4, 6]) +// >>> b = np.array([2, 4, 2]) +// >>> a == b +// array([ True, True, False]) +// +//go:linkname Equal py.equal +func Equal(__llgo_va_list ...interface{}) *py.Object +// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the exponential of all elements in the input array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array, element-wise exponential of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. +// exp2 : Calculate ``2**x`` for all elements in the array. +// +// Notes +// ----- +// The irrational number ``e`` is also known as Euler's number. It is +// approximately 2.718281, and is the base of the natural logarithm, +// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, +// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. +// +// For complex arguments, ``x = a + ib``, we can write +// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already +// known (it is the real argument, described above). The second term, +// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with +// magnitude 1 and a periodic phase. +// +// References +// ---------- +// .. [1] Wikipedia, "Exponential function", +// https://en.wikipedia.org/wiki/Exponential_function +// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions +// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, +// https://personal.math.ubc.ca/~cbm/aands/page_69.htm +// +// Examples +// -------- +// Plot the magnitude and phase of ``exp(x)`` in the complex plane: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) +// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane +// >>> out = np.exp(xx) +// +// >>> plt.subplot(121) +// >>> plt.imshow(np.abs(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') +// >>> plt.title('Magnitude of exp(x)') +// +// >>> plt.subplot(122) +// >>> plt.imshow(np.angle(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') +// >>> plt.title('Phase (angle) of exp(x)') +// >>> plt.show() +// +//go:linkname Exp py.exp +func Exp(__llgo_va_list ...interface{}) *py.Object +// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate `2**p` for all `p` in the input array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise 2 to the power `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// power +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// +// +// Examples +// -------- +// >>> np.exp2([2, 3]) +// array([ 4., 8.]) +// +//go:linkname Exp2 py.exp2 +func Exp2(__llgo_va_list ...interface{}) *py.Object +// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate ``exp(x) - 1`` for all elements in the array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise exponential minus one: ``out = exp(x) - 1``. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log1p : ``log(1 + x)``, the inverse of expm1. +// +// +// Notes +// ----- +// This function provides greater precision than ``exp(x) - 1`` +// for small values of ``x``. +// +// Examples +// -------- +// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to +// about 32 significant digits. This example shows the superiority of +// expm1 in this case. +// +// >>> np.expm1(1e-10) +// 1.00000000005e-10 +// >>> np.exp(1e-10) - 1 +// 1.000000082740371e-10 +// +//go:linkname Expm1 py.expm1 +func Expm1(__llgo_va_list ...interface{}) *py.Object +// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the absolute values element-wise. +// +// This function returns the absolute values (positive magnitude) of the +// data in `x`. Complex values are not handled, use `absolute` to find the +// absolute values of complex data. +// +// Parameters +// ---------- +// x : array_like +// The array of numbers for which the absolute values are required. If +// `x` is a scalar, the result `y` will also be a scalar. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The absolute values of `x`, the returned values are always floats. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// absolute : Absolute values including `complex` types. +// +// Examples +// -------- +// >>> np.fabs(-1) +// 1.0 +// >>> np.fabs([-1.2, 1.2]) +// array([ 1.2, 1.2]) +// +//go:linkname Fabs py.fabs +func Fabs(__llgo_va_list ...interface{}) *py.Object +// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the floor of the input, element-wise. +// +// The floor of the scalar `x` is the largest integer `i`, such that +// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The floor of each element in `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ceil, trunc, rint, fix +// +// Notes +// ----- +// Some spreadsheet programs calculate the "floor-towards-zero", where +// ``floor(-2.5) == -2``. NumPy instead uses the definition of +// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" +// function is called ``fix`` in NumPy. +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.floor(a) +// array([-2., -2., -1., 0., 1., 1., 2.]) +// +//go:linkname Floor py.floor +func Floor(__llgo_va_list ...interface{}) *py.Object +// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the largest integer smaller or equal to the division of the inputs. +// It is equivalent to the Python ``//`` operator and pairs with the +// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` +// up to roundoff. +// +// Parameters +// ---------- +// x1 : array_like +// Numerator. +// x2 : array_like +// Denominator. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// y = floor(`x1`/`x2`) +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// remainder : Remainder complementary to floor_divide. +// divmod : Simultaneous floor division and remainder. +// divide : Standard division. +// floor : Round a number to the nearest integer toward minus infinity. +// ceil : Round a number to the nearest integer toward infinity. +// +// Examples +// -------- +// >>> np.floor_divide(7,3) +// 2 +// >>> np.floor_divide([1., 2., 3., 4.], 2.5) +// array([ 0., 0., 1., 1.]) +// +// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` +// on ndarrays. +// +// >>> x1 = np.array([1., 2., 3., 4.]) +// >>> x1 // 2.5 +// array([0., 0., 1., 1.]) +// +//go:linkname FloorDivide py.floor_divide +func FloorDivide(__llgo_va_list ...interface{}) *py.Object +// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// First array elements raised to powers from second array, element-wise. +// +// Raise each base in `x1` to the positionally-corresponding power in `x2`. +// `x1` and `x2` must be broadcastable to the same shape. This differs from +// the power function in that integers, float16, and float32 are promoted to +// floats with a minimum precision of float64 so that the result is always +// inexact. The intent is that the function will return a usable result for +// negative powers and seldom overflow for positive powers. +// +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). +// +// .. versionadded:: 1.12.0 +// +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// power : power function that preserves type +// +// Examples +// -------- +// Cube each element in a list. +// +// >>> x1 = range(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.float_power(x1, 3) +// array([ 0., 1., 8., 27., 64., 125.]) +// +// Raise the bases to different exponents. +// +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.float_power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) +// +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.float_power(x1, x2) +// array([[ 0., 1., 8., 27., 16., 5.], +// [ 0., 1., 8., 27., 16., 5.]]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1, -4]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.float_power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.float_power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname FloatPower py.float_power +func FloatPower(__llgo_va_list ...interface{}) *py.Object +// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise maximum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// minimum, amin, nanmin +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// +// Examples +// -------- +// >>> np.fmax([2, 3, 4], [1, 5, 2]) +// array([ 2., 5., 4.]) +// +// >>> np.fmax(np.eye(2), [0.5, 2]) +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) +// +//go:linkname Fmax py.fmax +func Fmax(__llgo_va_list ...interface{}) *py.Object +// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise minimum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// maximum, amax, nanmax +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// +// Examples +// -------- +// >>> np.fmin([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) +// +// >>> np.fmin(np.eye(2), [0.5, 2]) +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) +// +// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) +// +//go:linkname Fmin py.fmin +func Fmin(__llgo_va_list ...interface{}) *py.Object +// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// This is the NumPy implementation of the C library function fmod, the +// remainder has the same sign as the dividend `x1`. It is equivalent to +// the Matlab(TM) ``rem`` function and should not be confused with the +// Python modulus operator ``x1 % x2``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend. +// x2 : array_like +// Divisor. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : array_like +// The remainder of the division of `x1` by `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// remainder : Equivalent to the Python ``%`` operator. +// divide +// +// Notes +// ----- +// The result of the modulo operation for negative dividend and divisors +// is bound by conventions. For `fmod`, the sign of result is the sign of +// the dividend, while for `remainder` the sign of the result is the sign +// of the divisor. The `fmod` function is equivalent to the Matlab(TM) +// ``rem`` function. +// +// Examples +// -------- +// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) +// array([-1, 0, -1, 1, 0, 1]) +// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) +// array([1, 0, 1, 1, 0, 1]) +// +// >>> np.fmod([5, 3], [2, 2.]) +// array([ 1., 1.]) +// >>> a = np.arange(-3, 3).reshape(3, 2) +// >>> a +// array([[-3, -2], +// [-1, 0], +// [ 1, 2]]) +// >>> np.fmod(a, [2,2]) +// array([[-1, 0], +// [-1, 0], +// [ 1, 0]]) +// +//go:linkname Fmod py.fmod +func Fmod(__llgo_va_list ...interface{}) *py.Object +// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Decompose the elements of x into mantissa and twos exponent. +// +// Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``. +// The mantissa lies in the open interval(-1, 1), while the twos +// exponent is a signed integer. +// +// Parameters +// ---------- +// x : array_like +// Array of numbers to be decomposed. +// out1 : ndarray, optional +// Output array for the mantissa. Must have the same shape as `x`. +// out2 : ndarray, optional +// Output array for the exponent. Must have the same shape as `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// mantissa : ndarray +// Floating values between -1 and 1. +// This is a scalar if `x` is a scalar. +// exponent : ndarray +// Integer exponents of 2. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`. +// +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. +// +// Examples +// -------- +// >>> x = np.arange(9) +// >>> y1, y2 = np.frexp(x) +// >>> y1 +// array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, +// 0.5 ]) +// >>> y2 +// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) +// >>> y1 * 2**y2 +// array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) +// +//go:linkname Frexp py.frexp +func Frexp(__llgo_va_list ...interface{}) *py.Object +// gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the greatest common divisor of ``|x1|`` and ``|x2|`` +// +// Parameters +// ---------- +// x1, x2 : array_like, int +// Arrays of values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// +// Returns +// ------- +// y : ndarray or scalar +// The greatest common divisor of the absolute value of the inputs +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// lcm : The lowest common multiple +// +// Examples +// -------- +// >>> np.gcd(12, 20) +// 4 +// >>> np.gcd.reduce([15, 25, 35]) +// 5 +// >>> np.gcd(np.arange(6), 20) +// array([20, 1, 2, 1, 4, 5]) +// +//go:linkname Gcd py.gcd +func Gcd(__llgo_va_list ...interface{}) *py.Object +// greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 > x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// +// See Also +// -------- +// greater_equal, less, less_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.greater([4,2],[2,2]) +// array([ True, False]) +// +// The ``>`` operator can be used as a shorthand for ``np.greater`` on +// ndarrays. +// +// >>> a = np.array([4, 2]) +// >>> b = np.array([2, 2]) +// >>> a > b +// array([ True, False]) +// +//go:linkname Greater py.greater +func Greater(__llgo_va_list ...interface{}) *py.Object +// greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 >= x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : bool or ndarray of bool +// 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. +// +// See Also +// -------- +// greater, less, less_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.greater_equal([4, 2, 1], [2, 2, 2]) +// array([ True, True, False]) +// +// The ``>=`` operator can be used as a shorthand for ``np.greater_equal`` +// on ndarrays. +// +// >>> a = np.array([4, 2, 1]) +// >>> b = np.array([2, 2, 2]) +// >>> a >= b +// array([ True, True, False]) +// +//go:linkname GreaterEqual py.greater_equal +func GreaterEqual(__llgo_va_list ...interface{}) *py.Object +// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the Heaviside step function. +// +// The Heaviside step function is defined as:: +// +// 0 if x1 < 0 +// heaviside(x1, x2) = x2 if x1 == 0 +// 1 if x1 > 0 +// +// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. +// +// Parameters +// ---------- +// x1 : array_like +// Input values. +// x2 : array_like +// The value of the function when x1 is 0. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The output array, element-wise Heaviside step function of `x1`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// .. versionadded:: 1.13.0 +// +// References +// ---------- +// .. Wikipedia, "Heaviside step function", +// https://en.wikipedia.org/wiki/Heaviside_step_function +// +// Examples +// -------- +// >>> np.heaviside([-1.5, 0, 2.0], 0.5) +// array([ 0. , 0.5, 1. ]) +// >>> np.heaviside([-1.5, 0, 2.0], 1) +// array([ 0., 1., 1.]) +// +//go:linkname Heaviside py.heaviside +func Heaviside(__llgo_va_list ...interface{}) *py.Object +// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Given the "legs" of a right triangle, return its hypotenuse. +// +// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. 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. +// (See Examples) +// +// Parameters +// ---------- +// x1, x2 : array_like +// Leg of the triangle(s). +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// z : ndarray +// The hypotenuse of the triangle(s). +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) +// +// Example showing broadcast of scalar_like argument: +// +// >>> np.hypot(3*np.ones((3, 3)), [4]) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) +// +//go:linkname Hypot py.hypot +func Hypot(__llgo_va_list ...interface{}) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. +// +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: +// +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' +// +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) +// +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) +// +//go:linkname Invert py.invert +func Invert(__llgo_va_list ...interface{}) *py.Object +// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for finiteness (not infinity and not Not a Number). +// +// The result is returned as a boolean array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray, bool +// True where ``x`` is not positive infinity, negative infinity, +// or NaN; false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isinf, isneginf, isposinf, isnan +// +// 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. +// +// Examples +// -------- +// >>> np.isfinite(1) +// True +// >>> np.isfinite(0) +// True +// >>> np.isfinite(np.nan) +// False +// >>> np.isfinite(np.inf) +// False +// >>> np.isfinite(np.NINF) +// False +// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) +// array([False, True, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isfinite(x, y) +// array([0, 1, 0]) +// >>> y +// array([0, 1, 0]) +// +//go:linkname Isfinite py.isfinite +func Isfinite(__llgo_va_list ...interface{}) *py.Object +// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for positive or negative infinity. +// +// Returns a boolean array of the same shape as `x`, True where ``x == +// +/-inf``, otherwise False. +// +// Parameters +// ---------- +// x : array_like +// Input values +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool (scalar) or boolean ndarray +// True where ``x`` is positive or negative infinity, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isneginf, isposinf, isnan, isfinite +// +// 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. +// +// Examples +// -------- +// >>> np.isinf(np.inf) +// True +// >>> np.isinf(np.nan) +// False +// >>> np.isinf(np.NINF) +// True +// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) +// array([ True, True, False, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isinf(x, y) +// array([1, 0, 1]) +// >>> y +// array([1, 0, 1]) +// +//go:linkname Isinf py.isinf +func Isinf(__llgo_va_list ...interface{}) *py.Object +// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for NaN and return result as a boolean array. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaN, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isinf, isneginf, isposinf, isfinite, isnat +// +// 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. +// +// Examples +// -------- +// >>> np.isnan(np.nan) +// True +// >>> np.isnan(np.inf) +// False +// >>> np.isnan([np.log(-1.),1.,np.log(0)]) +// array([ True, False, False]) +// +//go:linkname Isnan py.isnan +func Isnan(__llgo_va_list ...interface{}) *py.Object +// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for NaT (not a time) and return result as a boolean array. +// +// .. versionadded:: 1.13.0 +// +// Parameters +// ---------- +// x : array_like +// Input array with datetime or timedelta data type. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaT, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isnan, isinf, isneginf, isposinf, isfinite +// +// Examples +// -------- +// >>> np.isnat(np.datetime64("NaT")) +// True +// >>> np.isnat(np.datetime64("2016-01-01")) +// False +// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) +// array([ True, False]) +// +//go:linkname Isnat py.isnat +func Isnat(__llgo_va_list ...interface{}) *py.Object +// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` +// +// Parameters +// ---------- +// x1, x2 : array_like, int +// Arrays of values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// +// Returns +// ------- +// y : ndarray or scalar +// The lowest common multiple of the absolute value of the inputs +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// gcd : The greatest common divisor +// +// Examples +// -------- +// >>> np.lcm(12, 20) +// 60 +// >>> np.lcm.reduce([3, 12, 20]) +// 60 +// >>> np.lcm.reduce([40, 12, 20]) +// 120 +// >>> np.lcm(np.arange(6), 20) +// array([ 0, 20, 20, 60, 20, 20]) +// +//go:linkname Lcm py.lcm +func Lcm(__llgo_va_list ...interface{}) *py.Object +// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns x1 * 2**x2, element-wise. +// +// The mantissas `x1` and twos exponents `x2` are used to construct +// floating point numbers ``x1 * 2**x2``. +// +// Parameters +// ---------- +// x1 : array_like +// Array of multipliers. +// x2 : array_like, int +// Array of twos exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The result of ``x1 * 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. +// +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. +// +// `ldexp` is useful as the inverse of `frexp`, if used by itself it is +// more clear to simply use the expression ``x1 * 2**x2``. +// +// Examples +// -------- +// >>> np.ldexp(5, np.arange(4)) +// array([ 5., 10., 20., 40.], dtype=float16) +// +// >>> x = np.arange(6) +// >>> np.ldexp(*np.frexp(x)) +// array([ 0., 1., 2., 3., 4., 5.]) +// +//go:linkname Ldexp py.ldexp +func Ldexp(__llgo_va_list ...interface{}) *py.Object +// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Shift the bits of an integer to the left. +// +// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. +// Since the internal representation of numbers is in binary format, this +// operation is equivalent to multiplying `x1` by ``2**x2``. +// +// Parameters +// ---------- +// x1 : array_like of integer type +// Input values. +// x2 : array_like of integer type +// Number of zeros to append to `x1`. Has to be non-negative. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : array of integer type +// Return `x1` with bits shifted `x2` times to the left. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// right_shift : Shift the bits of an integer to the right. +// binary_repr : Return the binary representation of the input number +// as a string. +// +// Examples +// -------- +// >>> np.binary_repr(5) +// '101' +// >>> np.left_shift(5, 2) +// 20 +// >>> np.binary_repr(20) +// '10100' +// +// >>> np.left_shift(5, [1,2,3]) +// array([10, 20, 40]) +// +// Note that the dtype of the second argument may change the dtype of the +// result and can lead to unexpected results in some cases (see +// :ref:`Casting Rules `): +// +// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 +// >>> print(a, type(a)) # Unexpected result due to upcasting +// 510 +// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) +// >>> print(b, type(b)) +// 254 +// +// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on +// ndarrays. +// +// >>> x1 = 5 +// >>> x2 = np.array([1, 2, 3]) +// >>> x1 << x2 +// array([10, 20, 40]) +// +//go:linkname LeftShift py.left_shift +func LeftShift(__llgo_va_list ...interface{}) *py.Object +// less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 < x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// greater, less_equal, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less([1, 2], [2, 2]) +// array([ True, False]) +// +// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. +// +// >>> a = np.array([1, 2]) +// >>> b = np.array([2, 2]) +// >>> a < b +// array([ True, False]) +// +//go:linkname Less py.less +func Less(__llgo_va_list ...interface{}) *py.Object +// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 <= x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// greater, less, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less_equal([4, 2, 1], [2, 2, 2]) +// array([False, True, True]) +// +// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on +// ndarrays. +// +// >>> a = np.array([4, 2, 1]) +// >>> b = np.array([2, 2, 2]) +// >>> a <= b +// array([False, True, True]) +// +//go:linkname LessEqual py.less_equal +func LessEqual(__llgo_va_list ...interface{}) *py.Object +// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Natural logarithm, element-wise. +// +// The natural logarithm `log` is the inverse of the exponential function, +// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base +// `e`. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The natural logarithm of `x`, element-wise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log10, log2, log1p, emath.log +// +// Notes +// ----- +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log` always returns real output. For +// each value that cannot be expressed as a real number or infinity, it +// yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log([1, np.e, np.e**2, 0]) +// array([ 0., 1., 2., -Inf]) +// +//go:linkname Log py.log +func Log(__llgo_va_list ...interface{}) *py.Object +// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the base 10 logarithm of the input array, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The logarithm to the base 10 of `x`, element-wise. NaNs are +// returned where x is negative. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.log10 +// +// Notes +// ----- +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `10**z = x`. The convention is to return the +// `z` whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log10` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log10` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. +// `log10` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log10([1e-15, -3.]) +// array([-15., nan]) +// +//go:linkname Log10 py.log10 +func Log10(__llgo_va_list ...interface{}) *py.Object +// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the natural logarithm of one plus the input array, element-wise. +// +// Calculates ``log(1 + x)``. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Natural logarithm of `1 + x`, element-wise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// expm1 : ``exp(x) - 1``, the inverse of `log1p`. +// +// Notes +// ----- +// For real-valued input, `log1p` is accurate also for `x` so small +// that `1 + x == 1` in floating-point accuracy. +// +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = 1 + x`. The convention is to return +// the `z` whose imaginary part lies in `[-pi, pi]`. +// +// For real-valued input data types, `log1p` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log1p` is a complex analytical function that +// has a branch cut `[-inf, -1]` and is continuous from above on it. +// `log1p` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log1p(1e-99) +// 1e-99 +// >>> np.log(1 + 1e-99) +// 0.0 +// +//go:linkname Log1p py.log1p +func Log1p(__llgo_va_list ...interface{}) *py.Object +// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Base-2 logarithm of `x`. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Base-2 logarithm of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log, log10, log1p, emath.log2 +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `2**z = x`. The convention is to return the `z` +// whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log2` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log2` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// Examples +// -------- +// >>> x = np.array([0, 1, 2, 2**4]) +// >>> np.log2(x) +// array([-Inf, 0., 1., 4.]) +// +// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) +// >>> np.log2(xi) +// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) +// +//go:linkname Log2 py.log2 +func Log2(__llgo_va_list ...interface{}) *py.Object +// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Logarithm of the sum of exponentiations of the inputs. +// +// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in +// statistics where the calculated probabilities of events may be so small +// as to exceed the range of normal floating point numbers. In such cases +// the logarithm of the calculated probability is stored. This function +// allows adding probabilities stored in such a fashion. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray +// Logarithm of ``exp(x1) + exp(x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> prob1 = np.log(1e-50) +// >>> prob2 = np.log(2.5e-50) +// >>> prob12 = np.logaddexp(prob1, prob2) +// >>> prob12 +// -113.87649168120691 +// >>> np.exp(prob12) +// 3.5000000000000057e-50 +// +//go:linkname Logaddexp py.logaddexp +func Logaddexp(__llgo_va_list ...interface{}) *py.Object +// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Logarithm of the sum of exponentiations of the inputs in base-2. +// +// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine +// learning when the calculated probabilities of events may be so small as +// to exceed the range of normal floating point numbers. In such cases +// the base-2 logarithm of the calculated probability can be used instead. +// This function allows adding probabilities stored in such a fashion. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray +// Base-2 logarithm of ``2**x1 + 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logaddexp: Logarithm of the sum of exponentiations of the inputs. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> prob1 = np.log2(1e-50) +// >>> prob2 = np.log2(2.5e-50) +// >>> prob12 = np.logaddexp2(prob1, prob2) +// >>> prob1, prob2, prob12 +// (-166.09640474436813, -164.77447664948076, -164.28904982231052) +// >>> 2**prob12 +// 3.4999999999999914e-50 +// +//go:linkname Logaddexp2 py.logaddexp2 +func Logaddexp2(__llgo_va_list ...interface{}) *py.Object +// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 AND x2 element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// Boolean result of the logical AND operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or, logical_not, logical_xor +// bitwise_and +// +// Examples +// -------- +// >>> np.logical_and(True, False) +// False +// >>> np.logical_and([True, False], [False, False]) +// array([False, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_and(x>1, x<4) +// array([False, False, True, True, False]) +// +// +// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on +// boolean ndarrays. +// +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a & b +// array([False, False]) +// +//go:linkname LogicalAnd py.logical_and +func LogicalAnd(__llgo_va_list ...interface{}) *py.Object +// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of NOT x element-wise. +// +// Parameters +// ---------- +// x : array_like +// Logical NOT is applied to the elements of `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool or ndarray of bool +// 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. +// +// See Also +// -------- +// logical_and, logical_or, logical_xor +// +// Examples +// -------- +// >>> np.logical_not(3) +// False +// >>> np.logical_not([True, False, 0, 1]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_not(x<3) +// array([False, False, False, True, True]) +// +//go:linkname LogicalNot py.logical_not +func LogicalNot(__llgo_va_list ...interface{}) *py.Object +// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 OR x2 element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Logical OR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// Boolean result of the logical OR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and, logical_not, logical_xor +// bitwise_or +// +// Examples +// -------- +// >>> np.logical_or(True, False) +// True +// >>> np.logical_or([True, False], [False, False]) +// array([ True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_or(x < 1, x > 3) +// array([ True, False, False, False, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on +// boolean ndarrays. +// +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a | b +// array([ True, False]) +// +//go:linkname LogicalOr py.logical_or +func LogicalOr(__llgo_va_list ...interface{}) *py.Object +// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 XOR x2, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Logical XOR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool or ndarray of bool +// Boolean result of the logical XOR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and, logical_or, logical_not, bitwise_xor +// +// Examples +// -------- +// >>> np.logical_xor(True, False) +// True +// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_xor(x < 1, x > 3) +// array([ True, False, False, False, True]) +// +// Simple example showing support of broadcasting +// +// >>> np.logical_xor(0, np.eye(2)) +// array([[ True, False], +// [False, True]]) +// +//go:linkname LogicalXor py.logical_xor +func LogicalXor(__llgo_va_list ...interface{}) *py.Object +// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise maximum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// fmin, amin, nanmin +// +// Notes +// ----- +// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when +// neither x1 nor x2 are nans, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.maximum([2, 3, 4], [1, 5, 2]) +// array([2, 5, 4]) +// +// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.maximum(np.Inf, 1) +// inf +// +//go:linkname Maximum py.maximum +func Maximum(__llgo_va_list ...interface{}) *py.Object +// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise minimum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// fmax, amax, nanmax +// +// Notes +// ----- +// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when +// neither x1 nor x2 are NaNs, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.minimum([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) +// +// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) +// +// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.minimum(-np.Inf, 1) +// -inf +// +//go:linkname Minimum py.minimum +func Minimum(__llgo_va_list ...interface{}) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. +// +// .. warning:: +// +// This should not be confused with: +// +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor +// +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. +// +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) +// +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Mod py.mod +func Mod(__llgo_va_list ...interface{}) *py.Object +// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the fractional and integral parts of an array, element-wise. +// +// The fractional and integral parts are negative if the given number is +// negative. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y1 : ndarray +// Fractional part of `x`. +// This is a scalar if `x` is a scalar. +// y2 : ndarray +// Integral part of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// For integer input the return values are floats. +// +// See Also +// -------- +// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values +// switched, except it always has a positive remainder. +// +// Examples +// -------- +// >>> np.modf([0, 3.5]) +// (array([ 0. , 0.5]), array([ 0., 3.])) +// >>> np.modf(-0.5) +// (-0.5, -0) +// +//go:linkname Modf py.modf +func Modf(__llgo_va_list ...interface{}) *py.Object +// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Multiply arguments element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays to be multiplied. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The product of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to `x1` * `x2` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.multiply(2.0, 4.0) +// 8.0 +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.multiply(x1, x2) +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) +// +// The ``*`` operator can be used as a shorthand for ``np.multiply`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 * x2 +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) +// +//go:linkname Multiply py.multiply +func Multiply(__llgo_va_list ...interface{}) *py.Object +// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Numerical negative, element-wise. +// +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = -x`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.negative([1.,-1.]) +// array([-1., 1.]) +// +// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on +// ndarrays. +// +// >>> x1 = np.array(([1., -1.])) +// >>> -x1 +// array([-1., 1.]) +// +//go:linkname Negative py.negative +func Negative(__llgo_va_list ...interface{}) *py.Object +// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the next floating-point value after x1 towards x2, element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Values to find the next representable value of. +// x2 : array_like +// The direction where to look for the next representable value of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The next representable values of `x1` in the direction of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> eps = np.finfo(np.float64).eps +// >>> np.nextafter(1, 2) == eps + 1 +// True +// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] +// array([ True, True]) +// +//go:linkname Nextafter py.nextafter +func Nextafter(__llgo_va_list ...interface{}) *py.Object +// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return (x1 != x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// equal, greater, greater_equal, less, less_equal +// +// Examples +// -------- +// >>> np.not_equal([1.,2.], [1., 3.]) +// array([False, True]) +// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) +// array([[False, True], +// [False, True]]) +// +// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on +// ndarrays. +// +// >>> a = np.array([1., 2.]) +// >>> b = np.array([1., 3.]) +// >>> a != b +// array([False, True]) +// +//go:linkname NotEqual py.not_equal +func NotEqual(__llgo_va_list ...interface{}) *py.Object +// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Numerical positive, element-wise. +// +// .. versionadded:: 1.13.0 +// +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = +x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// Equivalent to `x.copy()`, but only defined for types that support +// arithmetic. +// +// Examples +// -------- +// +// >>> x1 = np.array(([1., -1.])) +// >>> np.positive(x1) +// array([ 1., -1.]) +// +// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on +// ndarrays. +// +// >>> x1 = np.array(([1., -1.])) +// >>> +x1 +// array([ 1., -1.]) +// +//go:linkname Positive py.positive +func Positive(__llgo_va_list ...interface{}) *py.Object +// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// First array elements raised to powers from second array, element-wise. +// +// Raise each base in `x1` to the positionally-corresponding power in +// `x2`. `x1` and `x2` must be broadcastable to the same shape. +// +// An integer type raised to a negative integer power will raise a +// ``ValueError``. +// +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). +// +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// float_power : power function that promotes integers to float +// +// Examples +// -------- +// Cube each element in an array. +// +// >>> x1 = np.arange(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.power(x1, 3) +// array([ 0, 1, 8, 27, 64, 125]) +// +// Raise the bases to different exponents. +// +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) +// +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.power(x1, x2) +// array([[ 0, 1, 8, 27, 16, 5], +// [ 0, 1, 8, 27, 16, 5]]) +// +// The ``**`` operator can be used as a shorthand for ``np.power`` on +// ndarrays. +// +// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) +// >>> x1 = np.arange(6) +// >>> x1 ** x2 +// array([ 0, 1, 8, 27, 16, 5]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1.0, -4.0]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname Power py.power +func Power(__llgo_va_list ...interface{}) *py.Object +// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. +// +// Parameters +// ---------- +// x : array_like +// Angle in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in degrees. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// deg2rad : Convert angles from degrees to radians. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// rad2deg(x) is ``180 * x / pi``. +// +// Examples +// -------- +// >>> np.rad2deg(np.pi/2) +// 90.0 +// +//go:linkname Rad2deg py.rad2deg +func Rad2deg(__llgo_va_list ...interface{}) *py.Object +// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Input array in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding radian values. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// deg2rad : equivalent function +// +// Examples +// -------- +// Convert a degree array to radians +// +// >>> deg = np.arange(12.) * 30. +// >>> np.radians(deg) +// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , +// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, +// 5.23598776, 5.75958653]) +// +// >>> out = np.zeros((deg.shape)) +// >>> ret = np.radians(deg, out) +// >>> ret is out +// True +// +//go:linkname Radians py.radians +func Radians(__llgo_va_list ...interface{}) *py.Object +// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the reciprocal of the argument, element-wise. +// +// Calculates ``1/x``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Return array. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// .. note:: +// This function is not designed to work with integers. +// +// For integer arguments with absolute value larger than 1 the result is +// always zero because of the way Python handles integer division. For +// integer zero the result is an overflow. +// +// Examples +// -------- +// >>> np.reciprocal(2.) +// 0.5 +// >>> np.reciprocal([1, 2., 3.33]) +// array([ 1. , 0.5 , 0.3003003]) +// +//go:linkname Reciprocal py.reciprocal +func Reciprocal(__llgo_va_list ...interface{}) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. +// +// .. warning:: +// +// This should not be confused with: +// +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor +// +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. +// +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) +// +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Remainder py.remainder +func Remainder(__llgo_va_list ...interface{}) *py.Object +// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Shift the bits of an integer to the right. +// +// Bits are shifted to the right `x2`. Because the internal +// representation of numbers is in binary format, this operation is +// equivalent to dividing `x1` by ``2**x2``. +// +// Parameters +// ---------- +// x1 : array_like, int +// Input values. +// x2 : array_like, int +// Number of bits to remove at the right of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray, int +// Return `x1` with bits shifted `x2` times to the right. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// left_shift : Shift the bits of an integer to the left. +// binary_repr : Return the binary representation of the input number +// as a string. +// +// Examples +// -------- +// >>> np.binary_repr(10) +// '1010' +// >>> np.right_shift(10, 1) +// 5 +// >>> np.binary_repr(5) +// '101' +// +// >>> np.right_shift(10, [1,2,3]) +// array([5, 2, 1]) +// +// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on +// ndarrays. +// +// >>> x1 = 10 +// >>> x2 = np.array([1,2,3]) +// >>> x1 >> x2 +// array([5, 2, 1]) +// +//go:linkname RightShift py.right_shift +func RightShift(__llgo_va_list ...interface{}) *py.Object +// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Round elements of the array to the nearest integer. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array is same shape and type as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// fix, ceil, floor, trunc +// +// Notes +// ----- +// For values exactly halfway between rounded decimal values, NumPy +// rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, +// -0.5 and 0.5 round to 0.0, etc. +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.rint(a) +// array([-2., -2., -0., 0., 2., 2., 2.]) +// +//go:linkname Rint py.rint +func Rint(__llgo_va_list ...interface{}) *py.Object +// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns an element-wise indication of the sign of a number. +// +// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan +// is returned for nan inputs. +// +// For complex inputs, the `sign` function returns +// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. +// +// complex(nan, 0) is returned for complex nan inputs. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The sign of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// There is more than one definition of sign in common use for complex +// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` +// which is different from a common alternative, :math:`x/|x|`. +// +// Examples +// -------- +// >>> np.sign([-5., 4.5]) +// array([-1., 1.]) +// >>> np.sign(0) +// 0 +// >>> np.sign(5-2j) +// (1+0j) +// +//go:linkname Sign py.sign +func Sign(__llgo_va_list ...interface{}) *py.Object +// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns element-wise True where signbit is set (less than zero). +// +// Parameters +// ---------- +// x : array_like +// The input value(s). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray of bool +// Output array, or reference to `out` if that was supplied. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.signbit(-1.2) +// True +// >>> np.signbit(np.array([1, -2.3, 2.1])) +// array([False, True, False]) +// +//go:linkname Signbit py.signbit +func Signbit(__llgo_va_list ...interface{}) *py.Object +// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric sine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : array_like +// The sine of each element of x. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// arcsin, sinh, cos +// +// Notes +// ----- +// The sine is one of the fundamental functions of trigonometry (the +// mathematical study of triangles). Consider a circle of radius 1 +// centered on the origin. A ray comes in from the :math:`+x` axis, makes +// an angle at the origin (measured counter-clockwise from that axis), and +// departs from the origin. The :math:`y` coordinate of the outgoing +// ray's intersection with the unit circle is the sine of that angle. It +// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The +// function has zeroes where the angle is a multiple of :math:`\pi`. +// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. +// The numerous properties of the sine and related functions are included +// in any standard trigonometry text. +// +// Examples +// -------- +// Print sine of one angle: +// +// >>> np.sin(np.pi/2.) +// 1.0 +// +// Print sines of an array of angles given in degrees: +// +// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) +// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) +// +// Plot the sine function: +// +// >>> import matplotlib.pylab as plt +// >>> x = np.linspace(-np.pi, np.pi, 201) +// >>> plt.plot(x, np.sin(x)) +// >>> plt.xlabel('Angle [rad]') +// >>> plt.ylabel('sin(x)') +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Sin py.sin +func Sin(__llgo_va_list ...interface{}) *py.Object +// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Hyperbolic sine, element-wise. +// +// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or +// ``-1j * np.sin(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding hyperbolic sine values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// +// Examples +// -------- +// >>> np.sinh(0) +// 0.0 +// >>> np.sinh(np.pi*1j/2) +// 1j +// >>> np.sinh(np.pi*1j) # (exact value is 0) +// 1.2246063538223773e-016j +// >>> # Discrepancy due to vagaries of floating point arithmetic. +// +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.sinh([0.1], out1) +// >>> out2 is out1 +// True +// +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Sinh py.sinh +func Sinh(__llgo_va_list ...interface{}) *py.Object +// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the distance between x and the nearest adjacent number. +// +// Parameters +// ---------- +// x : array_like +// Values to find the spacing of. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The spacing of values of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// It can be considered as a generalization of EPS: +// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there +// should not be any representable number between ``x + spacing(x)`` and +// x for any finite x. +// +// Spacing of +- inf and NaN is NaN. +// +// Examples +// -------- +// >>> np.spacing(1) == np.finfo(np.float64).eps +// True +// +//go:linkname Spacing py.spacing +func Spacing(__llgo_va_list ...interface{}) *py.Object +// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the non-negative square-root of an array, element-wise. +// +// Parameters +// ---------- +// x : array_like +// The values whose square-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the positive +// square-root of each element in `x`. If any element in `x` is +// complex, a complex array is returned (and the square-roots of +// negative reals are calculated). If all of the elements in `x` +// are real, so is `y`, with negative elements returning ``nan``. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.sqrt +// A version which returns complex numbers when given negative reals. +// Note that 0.0 and -0.0 are handled differently for complex inputs. +// +// Notes +// ----- +// *sqrt* has--consistent with common convention--as its branch cut the +// real "interval" [`-inf`, 0), and is continuous from above on it. +// A branch cut is a curve in the complex plane across which a given +// complex function fails to be continuous. +// +// Examples +// -------- +// >>> np.sqrt([1,4,9]) +// array([ 1., 2., 3.]) +// +// >>> np.sqrt([4, -1, -3+4J]) +// array([ 2.+0.j, 0.+1.j, 1.+2.j]) +// +// >>> np.sqrt([4, -1, np.inf]) +// array([ 2., nan, inf]) +// +//go:linkname Sqrt py.sqrt +func Sqrt(__llgo_va_list ...interface{}) *py.Object +// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the element-wise square of the input. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise `x*x`, of the same shape and dtype as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// numpy.linalg.matrix_power +// sqrt +// power +// +// Examples +// -------- +// >>> np.square([-1j, 1]) +// array([-1.-0.j, 1.+0.j]) +// +//go:linkname Square py.square +func Square(__llgo_va_list ...interface{}) *py.Object +// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Subtract arguments, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays to be subtracted from each other. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The difference of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to ``x1 - x2`` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.subtract(1.0, 4.0) +// -3.0 +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.subtract(x1, x2) +// array([[ 0., 0., 0.], +// [ 3., 3., 3.], +// [ 6., 6., 6.]]) +// +// The ``-`` operator can be used as a shorthand for ``np.subtract`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 - x2 +// array([[0., 0., 0.], +// [3., 3., 3.], +// [6., 6., 6.]]) +// +//go:linkname Subtract py.subtract +func Subtract(__llgo_va_list ...interface{}) *py.Object +// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute tangent element-wise. +// +// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding tangent values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. +// +// Examples +// -------- +// >>> from math import pi +// >>> np.tan(np.array([-pi,pi/2,pi])) +// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) +// >>> +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Tan py.tan +func Tan(__llgo_va_list ...interface{}) *py.Object +// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute hyperbolic tangent element-wise. +// +// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding hyperbolic tangent values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// https://personal.math.ubc.ca/~cbm/aands/page_83.htm +// +// .. [2] Wikipedia, "Hyperbolic function", +// https://en.wikipedia.org/wiki/Hyperbolic_function +// +// Examples +// -------- +// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) +// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) +// +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.tanh([0.1], out1) +// >>> out2 is out1 +// True +// +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Tanh py.tanh +func Tanh(__llgo_va_list ...interface{}) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. +// +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. +// +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.divide(x1, x2) +// array([[nan, 1. , 1. ], +// [inf, 4. , 2.5], +// [inf, 7. , 4. ]]) +// +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) +// +//go:linkname TrueDivide py.true_divide +func TrueDivide(__llgo_va_list ...interface{}) *py.Object +// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truncated value of the input, element-wise. +// +// The truncated value of the scalar `x` is the nearest integer `i` which +// is closer to zero than `x` is. In short, the fractional part of the +// signed number `x` is discarded. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The truncated value of each element in `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ceil, floor, rint, fix +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.trunc(a) +// array([-1., -1., -0., 0., 1., 1., 2.]) +// +//go:linkname Trunc py.trunc +func Trunc(__llgo_va_list ...interface{}) *py.Object +// +// Return the scalar dtype or NumPy equivalent of Python type of an object. +// +// Parameters +// ---------- +// rep : any +// The object of which the type is returned. +// default : any, optional +// If given, this is returned for objects whose types can not be +// determined. If not given, None is returned for those objects. +// +// Returns +// ------- +// dtype : dtype or Python type +// The data type of `rep`. +// +// See Also +// -------- +// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype +// +// Examples +// -------- +// >>> np.obj2sctype(np.int32) +// +// >>> np.obj2sctype(np.array([1., 2.])) +// +// >>> np.obj2sctype(np.array([1.j])) +// +// +// >>> np.obj2sctype(dict) +// +// >>> np.obj2sctype('string') +// +// >>> np.obj2sctype(1, default=list) +// +// +// +// +//go:linkname Obj2sctype py.obj2sctype +func Obj2sctype(rep *py.Object, default_ *py.Object) *py.Object +// +// Return the string representation of a scalar dtype. +// +// Parameters +// ---------- +// sctype : scalar dtype or object +// If a scalar dtype, the corresponding string character is +// returned. If an object, `sctype2char` tries to infer its scalar type +// and then return the corresponding string character. +// +// Returns +// ------- +// typechar : str +// The string character corresponding to the scalar type. +// +// Raises +// ------ +// ValueError +// If `sctype` is an object for which the type can not be inferred. +// +// See Also +// -------- +// obj2sctype, issctype, issubsctype, mintypecode +// +// Examples +// -------- +// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: +// ... print(np.sctype2char(sctype)) +// l # may vary +// d +// D +// S +// O +// +// >>> x = np.array([1., 2-1.j]) +// >>> np.sctype2char(x) +// 'D' +// >>> np.sctype2char(list) +// 'O' +// +// +// +//go:linkname Sctype2char py.sctype2char +func Sctype2char(sctype *py.Object) *py.Object +// +// Return the scalar type of highest precision of the same kind as the input. +// +// Parameters +// ---------- +// t : dtype or dtype specifier +// The input data type. This can be a `dtype` object or an object that +// is convertible to a `dtype`. +// +// Returns +// ------- +// out : dtype +// The highest precision data type of the same kind (`dtype.kind`) as `t`. +// +// See Also +// -------- +// obj2sctype, mintypecode, sctype2char +// dtype +// +// Examples +// -------- +// >>> np.maximum_sctype(int) +// +// >>> np.maximum_sctype(np.uint8) +// +// >>> np.maximum_sctype(complex) +// # may vary +// +// >>> np.maximum_sctype(str) +// +// +// >>> np.maximum_sctype('i2') +// +// >>> np.maximum_sctype('f4') +// # may vary +// +// +// +//go:linkname MaximumSctype py.maximum_sctype +func MaximumSctype(t *py.Object) *py.Object +// +// Determines whether the given object represents a scalar data-type. +// +// Parameters +// ---------- +// rep : any +// If `rep` is an instance of a scalar dtype, True is returned. If not, +// False is returned. +// +// Returns +// ------- +// out : bool +// Boolean result of check whether `rep` is a scalar dtype. +// +// See Also +// -------- +// issubsctype, issubdtype, obj2sctype, sctype2char +// +// Examples +// -------- +// >>> np.issctype(np.int32) +// True +// >>> np.issctype(list) +// False +// >>> np.issctype(1.1) +// False +// +// Strings are also a scalar type: +// +// >>> np.issctype(np.dtype('str')) +// True +// +// +// +//go:linkname Issctype py.issctype +func Issctype(rep *py.Object) *py.Object +// +// Determine common type following standard coercion rules. +// +// .. deprecated:: NumPy 1.25 +// +// This function is deprecated, use `numpy.promote_types` or +// `numpy.result_type` instead. To achieve semantics for the +// `scalar_types` argument, use `numpy.result_type` and pass the Python +// values `0`, `0.0`, or `0j`. +// This will give the same results in almost all cases. +// More information and rare exception can be found in the +// `NumPy 1.25 release notes `_. +// +// Parameters +// ---------- +// array_types : sequence +// A list of dtypes or dtype convertible objects representing arrays. +// scalar_types : sequence +// A list of dtypes or dtype convertible objects representing scalars. +// +// Returns +// ------- +// datatype : dtype +// The common data type, which is the maximum of `array_types` ignoring +// `scalar_types`, unless the maximum of `scalar_types` is of a +// different kind (`dtype.kind`). If the kind is not understood, then +// None is returned. +// +// See Also +// -------- +// dtype, common_type, can_cast, mintypecode +// +// Examples +// -------- +// >>> np.find_common_type([], [np.int64, np.float32, complex]) +// dtype('complex128') +// >>> np.find_common_type([np.int64, np.float32], []) +// dtype('float64') +// +// The standard casting rules ensure that a scalar cannot up-cast an +// array unless the scalar is of a fundamentally different kind of data +// (i.e. under a different hierarchy in the data type hierarchy) then +// the array: +// +// >>> np.find_common_type([np.float32], [np.int64, np.float64]) +// dtype('float32') +// +// Complex is of a different type, so it up-casts the float in the +// `array_types` argument: +// +// >>> np.find_common_type([np.float32], [complex]) +// dtype('complex128') +// +// Type specifier strings are convertible to dtypes and can therefore +// be used instead of dtypes: +// +// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) +// dtype('complex128') +// +// +// +//go:linkname FindCommonType py.find_common_type +func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object +// +// Returns True if first argument is a typecode lower/equal in type hierarchy. +// +// This is like the builtin :func:`issubclass`, but for `dtype`\ s. +// +// Parameters +// ---------- +// arg1, arg2 : dtype_like +// `dtype` or object coercible to one +// +// Returns +// ------- +// out : bool +// +// See Also +// -------- +// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. +// issubsctype, issubclass_ +// +// Examples +// -------- +// `issubdtype` can be used to check the type of arrays: +// +// >>> ints = np.array([1, 2, 3], dtype=np.int32) +// >>> np.issubdtype(ints.dtype, np.integer) +// True +// >>> np.issubdtype(ints.dtype, np.floating) +// False +// +// >>> floats = np.array([1, 2, 3], dtype=np.float32) +// >>> np.issubdtype(floats.dtype, np.integer) +// False +// >>> np.issubdtype(floats.dtype, np.floating) +// True +// +// Similar types of different sizes are not subdtypes of each other: +// +// >>> np.issubdtype(np.float64, np.float32) +// False +// >>> np.issubdtype(np.float32, np.float64) +// False +// +// but both are subtypes of `floating`: +// +// >>> np.issubdtype(np.float64, np.floating) +// True +// >>> np.issubdtype(np.float32, np.floating) +// True +// +// For convenience, dtype-like objects are allowed too: +// +// >>> np.issubdtype('S1', np.string_) +// True +// >>> np.issubdtype('i4', np.signedinteger) +// True +// +// +// +//go:linkname Issubdtype py.issubdtype +func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Set a Python function to be used when pretty printing arrays. +// +// Parameters +// ---------- +// f : function or None +// Function to be used to pretty print arrays. The function should expect +// a single array argument and return a string of the representation of +// the array. If None, the function is reset to the default NumPy function +// to print arrays. +// repr : bool, optional +// If True (default), the function for pretty printing (``__repr__``) +// is set, if False the function that returns the default string +// representation (``__str__``) is set. +// +// See Also +// -------- +// set_printoptions, get_printoptions +// +// Examples +// -------- +// >>> def pprint(arr): +// ... return 'HA! - What are you going to do now?' +// ... +// >>> np.set_string_function(pprint) +// >>> a = np.arange(10) +// >>> a +// HA! - What are you going to do now? +// >>> _ = a +// >>> # [0 1 2 3 4 5 6 7 8 9] +// +// We can reset the function to the default: +// +// >>> np.set_string_function(None) +// >>> a +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// +// `repr` affects either pretty printing or normal string representation. +// Note that ``__repr__`` is still affected by setting ``__str__`` +// because the width of each array element in the returned string becomes +// equal to the length of the result of ``__str__()``. +// +// >>> x = np.arange(4) +// >>> np.set_string_function(lambda x:'random', repr=False) +// >>> x.__str__() +// 'random' +// >>> x.__repr__() +// 'array([0, 1, 2, 3])' +// +// +// +//go:linkname SetStringFunction py.set_string_function +func SetStringFunction(f *py.Object, repr *py.Object) *py.Object +// +// Set printing options. +// +// These options determine the way floating point numbers, arrays and +// other NumPy objects are displayed. +// +// Parameters +// ---------- +// precision : int or None, optional +// Number of digits of precision for floating point output (default 8). +// May be None if `floatmode` is not `fixed`, to print as many digits as +// necessary to uniquely specify the value. +// threshold : int, optional +// Total number of array elements which trigger summarization +// rather than full repr (default 1000). +// To always use the full repr without summarization, pass `sys.maxsize`. +// edgeitems : int, optional +// Number of array items in summary at beginning and end of +// each dimension (default 3). +// linewidth : int, optional +// The number of characters per line for the purpose of inserting +// line breaks (default 75). +// suppress : bool, optional +// If True, always print floating point numbers using fixed point +// notation, in which case numbers equal to zero in the current precision +// will print as zero. If False, then scientific notation is used when +// absolute value of the smallest number is < 1e-4 or the ratio of the +// maximum absolute value to the minimum is > 1e3. The default is False. +// nanstr : str, optional +// String representation of floating point not-a-number (default nan). +// infstr : str, optional +// String representation of floating point infinity (default inf). +// sign : string, either '-', '+', or ' ', optional +// Controls printing of the sign of floating-point types. If '+', always +// print the sign of positive values. If ' ', always prints a space +// (whitespace character) in the sign position of positive values. If +// '-', omit the sign character of positive values. (default '-') +// formatter : dict of callables, optional +// If not None, the keys should indicate the type(s) that the respective +// formatting function applies to. Callables should return a string. +// Types that are not specified (by their corresponding keys) are handled +// by the default formatters. Individual types for which a formatter +// can be set are: +// +// - 'bool' +// - 'int' +// - 'timedelta' : a `numpy.timedelta64` +// - 'datetime' : a `numpy.datetime64` +// - 'float' +// - 'longfloat' : 128-bit floats +// - 'complexfloat' +// - 'longcomplexfloat' : composed of two 128-bit floats +// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` +// - 'object' : `np.object_` arrays +// +// Other keys that can be used to set a group of types at once are: +// +// - 'all' : sets all types +// - 'int_kind' : sets 'int' +// - 'float_kind' : sets 'float' and 'longfloat' +// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' +// - 'str_kind' : sets 'numpystr' +// floatmode : str, optional +// Controls the interpretation of the `precision` option for +// floating-point types. Can take the following values +// (default maxprec_equal): +// +// * 'fixed': Always print exactly `precision` fractional digits, +// even if this would print more or fewer digits than +// necessary to specify the value uniquely. +// * 'unique': Print the minimum number of fractional digits necessary +// to represent each value uniquely. Different elements may +// have a different number of digits. The value of the +// `precision` option is ignored. +// * 'maxprec': Print at most `precision` fractional digits, but if +// an element can be uniquely represented with fewer digits +// only print it with that many. +// * 'maxprec_equal': Print at most `precision` fractional digits, +// but if every element in the array can be uniquely +// represented with an equal number of fewer digits, use that +// many digits for all elements. +// legacy : string or `False`, optional +// If set to the string `'1.13'` enables 1.13 legacy printing mode. This +// approximates numpy 1.13 print output by including a space in the sign +// position of floats and different behavior for 0d arrays. This also +// enables 1.21 legacy printing mode (described below). +// +// If set to the string `'1.21'` enables 1.21 legacy printing mode. This +// approximates numpy 1.21 print output of complex structured dtypes +// by not inserting spaces after commas that separate fields and after +// colons. +// +// If set to `False`, disables legacy mode. +// +// Unrecognized strings will be ignored with a warning for forward +// compatibility. +// +// .. versionadded:: 1.14.0 +// .. versionchanged:: 1.22.0 +// +// See Also +// -------- +// get_printoptions, printoptions, set_string_function, array2string +// +// Notes +// ----- +// `formatter` is always reset with a call to `set_printoptions`. +// +// Use `printoptions` as a context manager to set the values temporarily. +// +// Examples +// -------- +// Floating point precision can be set: +// +// >>> np.set_printoptions(precision=4) +// >>> np.array([1.123456789]) +// [1.1235] +// +// Long arrays can be summarised: +// +// >>> np.set_printoptions(threshold=5) +// >>> np.arange(10) +// array([0, 1, 2, ..., 7, 8, 9]) +// +// Small results can be suppressed: +// +// >>> eps = np.finfo(float).eps +// >>> x = np.arange(4.) +// >>> x**2 - (x + eps)**2 +// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) +// >>> np.set_printoptions(suppress=True) +// >>> x**2 - (x + eps)**2 +// array([-0., -0., 0., 0.]) +// +// A custom formatter can be used to display array elements as desired: +// +// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) +// >>> x = np.arange(3) +// >>> x +// array([int: 0, int: -1, int: -2]) +// >>> np.set_printoptions() # formatter gets reset +// >>> x +// array([0, 1, 2]) +// +// To put back the default options, you can use: +// +// >>> np.set_printoptions(edgeitems=3, infstr='inf', +// ... linewidth=75, nanstr='nan', precision=8, +// ... suppress=False, threshold=1000, formatter=None) +// +// Also to temporarily override options, use `printoptions` as a context manager: +// +// >>> with np.printoptions(precision=2, suppress=True, threshold=5): +// ... np.linspace(0, 10, 10) +// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) +// +// +// +//go:linkname SetPrintoptions py.set_printoptions +func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object +// +// Return the current print options. +// +// Returns +// ------- +// print_opts : dict +// Dictionary of current print options with keys +// +// - precision : int +// - threshold : int +// - edgeitems : int +// - linewidth : int +// - suppress : bool +// - nanstr : str +// - infstr : str +// - formatter : dict of callables +// - sign : str +// +// For a full description of these options, see `set_printoptions`. +// +// See Also +// -------- +// set_printoptions, printoptions, set_string_function +// +// +// +//go:linkname GetPrintoptions py.get_printoptions +func GetPrintoptions() *py.Object +// Context manager for setting print options. +// +// Set print options for the scope of the `with` block, and restore the old +// options at the end. See `set_printoptions` for the full description of +// available options. +// +// Examples +// -------- +// +// >>> from numpy.testing import assert_equal +// >>> with np.printoptions(precision=2): +// ... np.array([2.0]) / 3 +// array([0.67]) +// +// The `as`-clause of the `with`-statement gives the current print options: +// +// >>> with np.printoptions(precision=2) as opts: +// ... assert_equal(opts, np.get_printoptions()) +// +// See Also +// -------- +// set_printoptions, get_printoptions +// +// +// +//go:linkname Printoptions py.printoptions +func Printoptions(__llgo_va_list ...interface{}) *py.Object +// +// Format a floating-point scalar as a decimal string in positional notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed, or if `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// fractional : boolean, optional +// If `True`, the cutoffs of `precision` and `min_digits` refer to the +// total number of digits after the decimal point, including leading +// zeros. +// If `False`, `precision` and `min_digits` refer to the total number of +// significant digits, before or after the decimal point, ignoring leading +// zeros. +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// pad_right : non-negative integer, optional +// Pad the right side of the string with whitespace until at least that +// many characters are to the right of the decimal point. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. Only has an effect if `unique=True` +// in which case additional digits past those necessary to uniquely +// identify the value may be printed, rounding the last additional digit. +// +// -- versionadded:: 1.21.0 +// +// Returns +// ------- +// rep : string +// The string representation of the floating point value +// +// See Also +// -------- +// format_float_scientific +// +// Examples +// -------- +// >>> np.format_float_positional(np.float32(np.pi)) +// '3.1415927' +// >>> np.format_float_positional(np.float16(np.pi)) +// '3.14' +// >>> np.format_float_positional(np.float16(0.3)) +// '0.3' +// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) +// '0.3000488281' +// +// +//go:linkname FormatFloatPositional py.format_float_positional +func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object +// +// Format a floating-point scalar as a decimal string in scientific notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed. If `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// exp_digits : non-negative integer, optional +// Pad the exponent with zeros until it contains at least this many digits. +// If omitted, the exponent will be at least 2 digits. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. This only has an effect for +// `unique=True`. In that case more digits than necessary to uniquely +// identify the value may be printed and rounded unbiased. +// +// -- versionadded:: 1.21.0 +// +// Returns +// ------- +// rep : string +// The string representation of the floating point value +// +// See Also +// -------- +// format_float_positional +// +// Examples +// -------- +// >>> np.format_float_scientific(np.float32(np.pi)) +// '3.1415927e+00' +// >>> s = np.float32(1.23e24) +// >>> np.format_float_scientific(s, unique=False, precision=15) +// '1.230000071797338e+24' +// >>> np.format_float_scientific(s, exp_digits=4) +// '1.23e+0024' +// +// +//go:linkname FormatFloatScientific py.format_float_scientific +func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object +// +// Return an ndarray of the provided type that satisfies requirements. +// +// This function is useful to be sure that an array with the correct flags +// is returned for passing to compiled code (perhaps through ctypes). +// +// Parameters +// ---------- +// a : array_like +// The object to be converted to a type-and-requirement-satisfying array. +// dtype : data-type +// The required data-type. If None preserve the current dtype. If your +// application requires the data to be in native byteorder, include +// a byteorder specification as a part of the dtype specification. +// requirements : str or sequence of str +// The requirements list can be any of the following +// +// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array +// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array +// * 'ALIGNED' ('A') - ensure a data-type aligned array +// * 'WRITEABLE' ('W') - ensure a writable array +// * 'OWNDATA' ('O') - ensure an array that owns its own data +// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array with specified requirements and type if given. +// +// See Also +// -------- +// asarray : Convert input to an ndarray. +// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// ndarray.flags : Information about the memory layout of the array. +// +// Notes +// ----- +// The returned array will be guaranteed to have the listed requirements +// by making a copy if needed. +// +// Examples +// -------- +// >>> x = np.arange(6).reshape(2,3) +// >>> x.flags +// C_CONTIGUOUS : True +// F_CONTIGUOUS : False +// OWNDATA : False +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False +// +// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) +// >>> y.flags +// C_CONTIGUOUS : False +// F_CONTIGUOUS : True +// OWNDATA : True +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False +// +// +// +//go:linkname Require py.require +func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object +// +// Set how floating-point errors are handled. +// +// Note that operations on integer scalar types (such as `int16`) are +// handled like floating point, and are affected by these settings. +// +// Parameters +// ---------- +// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Set treatment for all types of floating-point errors at once: +// +// - ignore: Take no action when the exception occurs. +// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). +// - raise: Raise a `FloatingPointError`. +// - call: Call a function specified using the `seterrcall` function. +// - print: Print a warning directly to ``stdout``. +// - log: Record error in a Log object specified by `seterrcall`. +// +// The default is not to change the current behavior. +// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for division by zero. +// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point overflow. +// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point underflow. +// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for invalid floating-point operation. +// +// Returns +// ------- +// old_settings : dict +// Dictionary containing the old settings. +// +// See also +// -------- +// seterrcall : Set a callback function for the 'call' mode. +// geterr, geterrcall, errstate +// +// Notes +// ----- +// The floating-point exceptions are defined in the IEEE 754 standard [1]_: +// +// - Division by zero: infinite result obtained from finite numbers. +// - Overflow: result too large to be expressed. +// - Underflow: result so close to zero that some precision +// was lost. +// - Invalid operation: result is not an expressible number, typically +// indicates that a NaN was produced. +// +// .. [1] https://en.wikipedia.org/wiki/IEEE_754 +// +// Examples +// -------- +// >>> old_settings = np.seterr(all='ignore') #seterr to known value +// >>> np.seterr(over='raise') +// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} +// >>> np.seterr(**old_settings) # reset to default +// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} +// +// >>> np.int16(32000) * np.int16(3) +// 30464 +// >>> old_settings = np.seterr(all='warn', over='raise') +// >>> np.int16(32000) * np.int16(3) +// Traceback (most recent call last): +// File "", line 1, in +// FloatingPointError: overflow encountered in scalar multiply +// +// >>> old_settings = np.seterr(all='print') +// >>> np.geterr() +// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} +// >>> np.int16(32000) * np.int16(3) +// 30464 +// +// +// +//go:linkname Seterr py.seterr +func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object +// +// Get the current way of handling floating-point errors. +// +// Returns +// ------- +// res : dict +// A dictionary with keys "divide", "over", "under", and "invalid", +// whose values are from the strings "ignore", "print", "log", "warn", +// "raise", and "call". The keys represent possible floating-point +// exceptions, and the values define how these exceptions are handled. +// +// See Also +// -------- +// geterrcall, seterr, seterrcall +// +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. +// +// Examples +// -------- +// >>> np.geterr() +// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) +// +// >>> oldsettings = np.seterr(all='warn', over='raise') +// >>> np.geterr() +// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) +// +// +// +//go:linkname Geterr py.geterr +func Geterr() *py.Object +// +// Set the size of the buffer used in ufuncs. +// +// Parameters +// ---------- +// size : int +// Size of buffer. +// +// +// +//go:linkname Setbufsize py.setbufsize +func Setbufsize(size *py.Object) *py.Object +// +// Return the size of the buffer used in ufuncs. +// +// Returns +// ------- +// getbufsize : int +// Size of ufunc buffer in bytes. +// +// +// +//go:linkname Getbufsize py.getbufsize +func Getbufsize() *py.Object +// +// Set the floating-point error callback function or log object. +// +// There are two ways to capture floating-point error messages. The first +// is to set the error-handler to 'call', using `seterr`. Then, set +// the function to call using this function. +// +// The second is to set the error-handler to 'log', using `seterr`. +// Floating-point errors then trigger a call to the 'write' method of +// the provided object. +// +// Parameters +// ---------- +// func : callable f(err, flag) or object with write method +// Function to call upon floating-point errors ('call'-mode) or +// object whose 'write' method is used to log such message ('log'-mode). +// +// The call function takes two arguments. The first is a string describing +// the type of error (such as "divide by zero", "overflow", "underflow", +// or "invalid value"), and the second is the status flag. The flag is a +// byte, whose four least-significant bits indicate the type of error, one +// of "divide", "over", "under", "invalid":: +// +// [0 0 0 0 divide over under invalid] +// +// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. +// +// If an object is provided, its write method should take one argument, +// a string. +// +// Returns +// ------- +// h : callable, log instance or None +// The old error handler. +// +// See Also +// -------- +// seterr, geterr, geterrcall +// +// Examples +// -------- +// Callback upon error: +// +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// ... +// +// >>> saved_handler = np.seterrcall(err_handler) +// >>> save_err = np.seterr(all='call') +// +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) +// +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} +// +// Log error message: +// +// >>> class Log: +// ... def write(self, msg): +// ... print("LOG: %s" % msg) +// ... +// +// >>> log = Log() +// >>> saved_handler = np.seterrcall(log) +// >>> save_err = np.seterr(all='log') +// +// >>> np.array([1, 2, 3]) / 0.0 +// LOG: Warning: divide by zero encountered in divide +// array([inf, inf, inf]) +// +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} +// +// +// +//go:linkname Seterrcall py.seterrcall +func Seterrcall(func_ *py.Object) *py.Object +// +// Return the current callback function used on floating-point errors. +// +// When the error handling for a floating-point error (one of "divide", +// "over", "under", or "invalid") is set to 'call' or 'log', the function +// that is called or the log instance that is written to is returned by +// `geterrcall`. This function or log instance has been set with +// `seterrcall`. +// +// Returns +// ------- +// errobj : callable, log instance or None +// The current error handler. If no handler was set through `seterrcall`, +// ``None`` is returned. +// +// See Also +// -------- +// seterrcall, seterr, geterr +// +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. +// +// Examples +// -------- +// >>> np.geterrcall() # we did not yet set a handler, returns None +// +// >>> oldsettings = np.seterr(all='call') +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// >>> oldhandler = np.seterrcall(err_handler) +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) +// +// >>> cur_handler = np.geterrcall() +// >>> cur_handler is err_handler +// True +// +// +// +//go:linkname Geterrcall py.geterrcall +func Geterrcall() *py.Object +// +// Return a description for the given data type code. +// +// Parameters +// ---------- +// char : str +// Data type code. +// +// Returns +// ------- +// out : str +// Description of the input data type code. +// +// See Also +// -------- +// dtype, typecodes +// +// Examples +// -------- +// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', +// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] +// >>> for typechar in typechars: +// ... print(typechar, ' : ', np.typename(typechar)) +// ... +// S1 : character +// ? : bool +// B : unsigned char +// D : complex double precision +// G : complex long double precision +// F : complex single precision +// I : unsigned integer +// H : unsigned short +// L : unsigned long integer +// O : object +// Q : unsigned long long integer +// S : string +// U : unicode +// V : void +// b : signed char +// d : double precision +// g : long precision +// f : single precision +// i : integer +// h : short +// l : long integer +// q : long long integer +// +// +// +//go:linkname Typename py.typename +func Typename(char *py.Object) *py.Object +// +// Return the character for the minimum-size type to which given types can +// be safely cast. +// +// The returned type character must represent the smallest size dtype such +// that an array of the returned type can handle the data from an array of +// all types in `typechars` (or if `typechars` is an array, then its +// dtype.char). +// +// Parameters +// ---------- +// typechars : list of str or array_like +// If a list of strings, each string should represent a dtype. +// If array_like, the character representation of the array dtype is used. +// typeset : str or list of str, optional +// The set of characters that the returned character is chosen from. +// The default set is 'GDFgdf'. +// default : str, optional +// The default character, this is returned if none of the characters in +// `typechars` matches a character in `typeset`. +// +// Returns +// ------- +// typechar : str +// The character representing the minimum-size type that was found. +// +// See Also +// -------- +// dtype, sctype2char, maximum_sctype +// +// Examples +// -------- +// >>> np.mintypecode(['d', 'f', 'S']) +// 'd' +// >>> x = np.array([1.1, 2-3.j]) +// >>> np.mintypecode(x) +// 'D' +// +// >>> np.mintypecode('abceh', default='G') +// 'G' +// +// +// +//go:linkname Mintypecode py.mintypecode +func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *py.Object) *py.Object +// +// Return the indices to access the main diagonal of an array. +// +// This returns a tuple of indices that can be used to access the main +// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape +// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for +// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` +// for ``i = [0..n-1]``. +// +// Parameters +// ---------- +// n : int +// The size, along each dimension, of the arrays for which the returned +// indices can be used. +// +// ndim : int, optional +// The number of dimensions. +// +// See Also +// -------- +// diag_indices_from +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Create a set of indices to access the diagonal of a (4, 4) array: +// +// >>> di = np.diag_indices(4) +// >>> di +// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// >>> a[di] = 100 +// >>> a +// array([[100, 1, 2, 3], +// [ 4, 100, 6, 7], +// [ 8, 9, 100, 11], +// [ 12, 13, 14, 100]]) +// +// Now, we create indices to manipulate a 3-D array: +// +// >>> d3 = np.diag_indices(2, 3) +// >>> d3 +// (array([0, 1]), array([0, 1]), array([0, 1])) +// +// And use it to set the diagonal of an array of zeros to 1: +// +// >>> a = np.zeros((2, 2, 2), dtype=int) +// >>> a[d3] = 1 +// >>> a +// array([[[1, 0], +// [0, 0]], +// [[0, 0], +// [0, 1]]]) +// +// +// +//go:linkname DiagIndices py.diag_indices +func DiagIndices(n *py.Object, ndim *py.Object) *py.Object +// +// Check whether or not an object can be iterated over. +// +// Parameters +// ---------- +// y : object +// Input object. +// +// Returns +// ------- +// b : bool +// Return ``True`` if the object has an iterator method or is a +// sequence and ``False`` otherwise. +// +// +// Examples +// -------- +// >>> np.iterable([1, 2, 3]) +// True +// >>> np.iterable(2) +// False +// +// Notes +// ----- +// In most cases, the results of ``np.iterable(obj)`` are consistent with +// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is +// the treatment of 0-dimensional arrays:: +// +// >>> from collections.abc import Iterable +// >>> a = np.array(1.0) # 0-dimensional numpy array +// >>> isinstance(a, Iterable) +// True +// >>> np.iterable(a) +// False +// +// +// +//go:linkname Iterable py.iterable +func Iterable(y *py.Object) *py.Object +// +// Display a message on a device. +// +// Parameters +// ---------- +// mesg : str +// Message to display. +// device : object +// Device to write message. If None, defaults to ``sys.stdout`` which is +// very similar to ``print``. `device` needs to have ``write()`` and +// ``flush()`` methods. +// linefeed : bool, optional +// Option whether to print a line feed or not. Defaults to True. +// +// Raises +// ------ +// AttributeError +// If `device` does not have a ``write()`` or ``flush()`` method. +// +// Examples +// -------- +// Besides ``sys.stdout``, a file-like object can also be used as it has +// both required methods: +// +// >>> from io import StringIO +// >>> buf = StringIO() +// >>> np.disp(u'"Display" in a file', device=buf) +// >>> buf.getvalue() +// '"Display" in a file\n' +// +// +// +//go:linkname Disp py.disp +func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object +// Convert the input to an array, checking for NaNs or Infs. +// +// Parameters +// ---------- +// a : array_like +// Input data, in any form that can be converted to an array. This +// includes lists, lists of tuples, tuples, tuples of tuples, tuples +// of lists and ndarrays. Success requires no NaNs or Infs. +// dtype : data-type, optional +// By default, the data-type is inferred from the input data. +// order : {'C', 'F', 'A', 'K'}, optional +// Memory layout. 'A' and 'K' depend on the order of input array a. +// 'C' row-major (C-style), +// 'F' column-major (Fortran-style) memory representation. +// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise +// 'K' (keep) preserve input order +// Defaults to 'C'. +// +// Returns +// ------- +// out : ndarray +// Array interpretation of `a`. No copy is performed if the input +// is already an ndarray. If `a` is a subclass of ndarray, a base +// class ndarray is returned. +// +// Raises +// ------ +// ValueError +// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). +// +// See Also +// -------- +// asarray : Create and array. +// asanyarray : Similar function which passes through subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfarray : Convert input to a floating point ndarray. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// fromiter : Create an array from an iterator. +// fromfunction : Construct an array by executing a function on grid +// positions. +// +// Examples +// -------- +// Convert a list into an array. If all elements are finite +// ``asarray_chkfinite`` is identical to ``asarray``. +// +// >>> a = [1, 2] +// >>> np.asarray_chkfinite(a, dtype=float) +// array([1., 2.]) +// +// Raises ValueError if array_like contains Nans or Infs. +// +// >>> a = [1, 2, np.inf] +// >>> try: +// ... np.asarray_chkfinite(a) +// ... except ValueError: +// ... print('ValueError') +// ... +// ValueError +// +// +// +//go:linkname AsarrayChkfinite py.asarray_chkfinite +func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// Return the Hamming window. +// +// The Hamming window is a taper formed by using a weighted cosine. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hanning, kaiser +// +// Notes +// ----- +// The Hamming window is defined as +// +// .. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 +// +// The Hamming was named for R. W. Hamming, an associate of J. W. Tukey +// and is described in Blackman and Tukey. It was recommended for +// smoothing the truncated autocovariance function in the time domain. +// Most references to the Hamming window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 109-110. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// +// Examples +// -------- +// >>> np.hamming(12) +// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary +// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, +// 0.15302337, 0.08 ]) +// +// Plot the window and the frequency response: +// +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hamming(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hamming window") +// Text(0.5, 1.0, 'Hamming window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Hamming window") +// Text(0.5, 1.0, 'Frequency response of Hamming window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() +// +// +// +//go:linkname Hamming py.hamming +func Hamming(M *py.Object) *py.Object +// +// Return the Hanning window. +// +// The Hanning window is a taper formed by using a weighted cosine. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : ndarray, shape(M,) +// The window, with the maximum value normalized to one (the value +// one appears only if `M` is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, kaiser +// +// Notes +// ----- +// The Hanning window is defined as +// +// .. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 +// +// The Hanning was named for Julius von Hann, an Austrian meteorologist. +// It is also known as the Cosine Bell. Some authors prefer that it be +// called a Hann window, to help avoid confusion with the very similar +// Hamming window. +// +// Most references to the Hanning window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 106-108. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// +// Examples +// -------- +// >>> np.hanning(12) +// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, +// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, +// 0.07937323, 0. ]) +// +// Plot the window and its frequency response: +// +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hanning(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hann window") +// Text(0.5, 1.0, 'Hann window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of the Hann window") +// Text(0.5, 1.0, 'Frequency response of the Hann window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() +// +// +// +//go:linkname Hanning py.hanning +func Hanning(M *py.Object) *py.Object +// +// Return the Bartlett window. +// +// The Bartlett window is very similar to a triangular window, except +// that the end points are at zero. It is often used in signal +// processing for tapering a signal, without generating too much +// ripple in the frequency domain. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : array +// The triangular window, with the maximum value normalized to one +// (the value one appears only if the number of samples is odd), with +// the first and last samples equal to zero. +// +// See Also +// -------- +// blackman, hamming, hanning, kaiser +// +// Notes +// ----- +// The Bartlett window is defined as +// +// .. math:: w(n) = \frac{2}{M-1} \left( +// \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| +// \right) +// +// Most references to the Bartlett window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. Note that convolution with this window produces linear +// interpolation. It is also known as an apodization (which means "removing +// the foot", i.e. smoothing discontinuities at the beginning and end of the +// sampled signal) or tapering function. The Fourier transform of the +// Bartlett window is the product of two sinc functions. Note the excellent +// discussion in Kanasewich [2]_. +// +// References +// ---------- +// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", +// Biometrika 37, 1-16, 1950. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 109-110. +// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal +// Processing", Prentice-Hall, 1999, pp. 468-471. +// .. [4] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 429. +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.bartlett(12) +// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary +// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, +// 0.18181818, 0. ]) +// +// Plot the window and its frequency response (requires SciPy and matplotlib): +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.bartlett(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Bartlett window") +// Text(0.5, 1.0, 'Bartlett window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Bartlett window") +// Text(0.5, 1.0, 'Frequency response of Bartlett window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() +// +// +// +//go:linkname Bartlett py.bartlett +func Bartlett(M *py.Object) *py.Object +// +// Return the Blackman window. +// +// The Blackman window is a taper formed by using the first three +// terms of a summation of cosines. It was designed to have close to the +// minimal leakage possible. It is close to optimal, only slightly worse +// than a Kaiser window. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an empty +// array is returned. +// +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value one +// appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, hamming, hanning, kaiser +// +// Notes +// ----- +// The Blackman window is defined as +// +// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) +// +// Most references to the Blackman window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. It is known as a +// "near optimal" tapering function, almost as good (by some measures) +// as the kaiser window. +// +// References +// ---------- +// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, +// Dover Publications, New York. +// +// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. +// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.blackman(12) +// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary +// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, +// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, +// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) +// +// Plot the window and the frequency response: +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.blackman(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Blackman window") +// Text(0.5, 1.0, 'Blackman window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Blackman window") +// Text(0.5, 1.0, 'Frequency response of Blackman window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() +// +// +// +//go:linkname Blackman py.blackman +func Blackman(M *py.Object) *py.Object +// +// Return the Kaiser window. +// +// The Kaiser window is a taper formed by using a Bessel function. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// beta : float +// Shape parameter for window. +// +// Returns +// ------- +// out : array +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, hanning +// +// Notes +// ----- +// The Kaiser window is defined as +// +// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} +// \right)/I_0(\beta) +// +// with +// +// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, +// +// where :math:`I_0` is the modified zeroth-order Bessel function. +// +// The Kaiser was named for Jim Kaiser, who discovered a simple +// approximation to the DPSS window based on Bessel functions. The Kaiser +// window is a very good approximation to the Digital Prolate Spheroidal +// Sequence, or Slepian window, which is the transform which maximizes the +// energy in the main lobe of the window relative to total energy. +// +// The Kaiser can approximate many other windows by varying the beta +// parameter. +// +// ==== ======================= +// beta Window shape +// ==== ======================= +// 0 Rectangular +// 5 Similar to a Hamming +// 6 Similar to a Hanning +// 8.6 Similar to a Blackman +// ==== ======================= +// +// A beta value of 14 is probably a good starting point. Note that as beta +// gets large, the window narrows, and so the number of samples needs to be +// large enough to sample the increasingly narrow spike, otherwise NaNs will +// get returned. +// +// Most references to the Kaiser window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by +// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. +// John Wiley and Sons, New York, (1966). +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 177-178. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.kaiser(12, 14) +// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary +// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, +// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, +// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) +// +// +// Plot the window and the frequency response: +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.kaiser(51, 14) +// >>> plt.plot(window) +// [] +// >>> plt.title("Kaiser window") +// Text(0.5, 1.0, 'Kaiser window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Kaiser window") +// Text(0.5, 1.0, 'Frequency response of Kaiser window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// (-0.5, 0.5, -100.0, ...) # may vary +// >>> plt.show() +// +// +// +//go:linkname Kaiser py.kaiser +func Kaiser(M *py.Object, beta *py.Object) *py.Object +// +// Add documentation to an existing object, typically one defined in C +// +// The purpose is to allow easier editing of the docstrings without requiring +// a re-compile. This exists primarily for internal use within numpy itself. +// +// Parameters +// ---------- +// place : str +// The absolute name of the module to import from +// obj : str +// The name of the object to add documentation to, typically a class or +// function name +// doc : {str, Tuple[str, str], List[Tuple[str, str]]} +// If a string, the documentation to apply to `obj` +// +// If a tuple, then the first element is interpreted as an attribute of +// `obj` and the second as the docstring to apply - ``(method, docstring)`` +// +// If a list, then each element of the list should be a tuple of length +// two - ``[(method1, docstring1), (method2, docstring2), ...]`` +// warn_on_python : bool +// If True, the default, emit `UserWarning` if this is used to attach +// documentation to a pure-python object. +// +// Notes +// ----- +// This routine never raises an error if the docstring can't be written, but +// will raise an error if the object being documented does not exist. +// +// This routine cannot modify read-only docstrings, as appear +// in new-style classes or built-in functions. Because this +// routine never raises an error the caller must check manually +// that the docstrings were changed. +// +// Since this function grabs the ``char *`` from a c-level str object and puts +// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of +// C-API best-practices, by: +// +// - modifying a `PyTypeObject` after calling `PyType_Ready` +// - calling `Py_INCREF` on the str and losing the reference, so the str +// will never be released +// +// If possible it should be avoided. +// +// +//go:linkname AddNewdoc py.add_newdoc +func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object +// Find the wrapper for the array with the highest priority. +// +// In case of ties, leftmost wins. If no wrapper is found, return None +// +// +//go:linkname GetArrayWrap py.get_array_wrap +func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object +// +// Broadcast the input shapes into a single shape. +// +// :ref:`Learn more about broadcasting here `. +// +// .. versionadded:: 1.20.0 +// +// Parameters +// ---------- +// `*args` : tuples of ints, or ints +// The shapes to be broadcast against each other. +// +// Returns +// ------- +// tuple +// Broadcasted shape. +// +// Raises +// ------ +// ValueError +// If the shapes are not compatible and cannot be broadcast according +// to NumPy's broadcasting rules. +// +// See Also +// -------- +// broadcast +// broadcast_arrays +// broadcast_to +// +// Examples +// -------- +// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) +// (3, 2) +// +// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) +// (5, 6, 7) +// +// +//go:linkname BroadcastShapes py.broadcast_shapes +func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object +// +// Return a 2-D array with ones on the diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// Number of rows in the output. +// M : int, optional +// Number of columns in the output. If None, defaults to `N`. +// k : int, optional +// Index of the diagonal: 0 (the default) refers to the main diagonal, +// a positive value refers to an upper diagonal, and a negative value +// to a lower diagonal. +// dtype : data-type, optional +// Data-type of the returned array. +// order : {'C', 'F'}, optional +// Whether the output should be stored in row-major (C-style) or +// column-major (Fortran-style) order in memory. +// +// .. versionadded:: 1.14.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// I : ndarray of shape (N,M) +// An array where all elements are equal to zero, except for the `k`-th +// diagonal, whose values are equal to one. +// +// See Also +// -------- +// identity : (almost) equivalent function +// diag : diagonal 2-D array from a 1-D array specified by the user. +// +// Examples +// -------- +// >>> np.eye(2, dtype=int) +// array([[1, 0], +// [0, 1]]) +// >>> np.eye(3, k=1) +// array([[0., 1., 0.], +// [0., 0., 1.], +// [0., 0., 0.]]) +// +// +// +//go:linkname Eye py.eye +func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// An array with ones at and below the given diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// Number of rows in the array. +// M : int, optional +// Number of columns in the array. +// By default, `M` is taken equal to `N`. +// k : int, optional +// The sub-diagonal at and below which the array is filled. +// `k` = 0 is the main diagonal, while `k` < 0 is below it, +// and `k` > 0 is above. The default is 0. +// dtype : dtype, optional +// Data type of the returned array. The default is float. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// tri : ndarray of shape (N, M) +// Array with its lower triangle filled with ones and zero elsewhere; +// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. +// +// Examples +// -------- +// >>> np.tri(3, 5, 2, dtype=int) +// array([[1, 1, 1, 0, 0], +// [1, 1, 1, 1, 0], +// [1, 1, 1, 1, 1]]) +// +// >>> np.tri(3, 5, -1) +// array([[0., 0., 0., 0., 0.], +// [1., 0., 0., 0., 0.], +// [1., 1., 0., 0., 0.]]) +// +// +// +//go:linkname Tri py.tri +func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object +// +// Return the indices to access (n, n) arrays, given a masking function. +// +// Assume `mask_func` is a function that, for a square array a of size +// ``(n, n)`` with a possible offset argument `k`, when called as +// ``mask_func(a, k)`` returns a new array with zeros in certain locations +// (functions like `triu` or `tril` do precisely this). Then this function +// returns the indices where the non-zero values would be located. +// +// Parameters +// ---------- +// n : int +// The returned indices will be valid to access arrays of shape (n, n). +// mask_func : callable +// A function whose call signature is similar to that of `triu`, `tril`. +// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. +// `k` is an optional argument to the function. +// k : scalar +// An optional argument which is passed through to `mask_func`. Functions +// like `triu`, `tril` take a second argument that is interpreted as an +// offset. +// +// Returns +// ------- +// indices : tuple of arrays. +// The `n` arrays of indices corresponding to the locations where +// ``mask_func(np.ones((n, n)), k)`` is True. +// +// See Also +// -------- +// triu, tril, triu_indices, tril_indices +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// These are the indices that would allow you to access the upper triangular +// part of any 3x3 array: +// +// >>> iu = np.mask_indices(3, np.triu) +// +// For example, if `a` is a 3x3 array: +// +// >>> a = np.arange(9).reshape(3, 3) +// >>> a +// array([[0, 1, 2], +// [3, 4, 5], +// [6, 7, 8]]) +// >>> a[iu] +// array([0, 1, 2, 4, 5, 8]) +// +// An offset can be passed also to the masking function. This gets us the +// indices starting on the first diagonal right of the main one: +// +// >>> iu1 = np.mask_indices(3, np.triu, 1) +// +// with which we now extract only three elements: +// +// >>> a[iu1] +// array([1, 2, 5]) +// +// +// +//go:linkname MaskIndices py.mask_indices +func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object +// +// Return the indices for the lower-triangle of an (n, m) array. +// +// Parameters +// ---------- +// n : int +// The row dimension of the arrays for which the returned +// indices will be valid. +// k : int, optional +// Diagonal offset (see `tril` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// +// +// Returns +// ------- +// inds : tuple of arrays +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. +// +// See also +// -------- +// triu_indices : similar function, for upper-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// tril, triu +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Compute two different sets of indices to access 4x4 arrays, one for the +// lower triangular part starting at the main diagonal, and one starting two +// diagonals further right: +// +// >>> il1 = np.tril_indices(4) +// >>> il2 = np.tril_indices(4, 2) +// +// Here is how they can be used with a sample array: +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Both for indexing: +// +// >>> a[il1] +// array([ 0, 4, 5, ..., 13, 14, 15]) +// +// And for assigning values: +// +// >>> a[il1] = -1 +// >>> a +// array([[-1, 1, 2, 3], +// [-1, -1, 6, 7], +// [-1, -1, -1, 11], +// [-1, -1, -1, -1]]) +// +// These cover almost the whole array (two diagonals right of the main one): +// +// >>> a[il2] = -10 +// >>> a +// array([[-10, -10, -10, 3], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10]]) +// +// +// +//go:linkname TrilIndices py.tril_indices +func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Return the indices for the upper-triangle of an (n, m) array. +// +// Parameters +// ---------- +// n : int +// The size of the arrays for which the returned indices will +// be valid. +// k : int, optional +// Diagonal offset (see `triu` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// +// +// Returns +// ------- +// inds : tuple, shape(2) of ndarrays, shape(`n`) +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. Can be used +// to slice a ndarray of shape(`n`, `n`). +// +// See also +// -------- +// tril_indices : similar function, for lower-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// triu, tril +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Compute two different sets of indices to access 4x4 arrays, one for the +// upper triangular part starting at the main diagonal, and one starting two +// diagonals further right: +// +// >>> iu1 = np.triu_indices(4) +// >>> iu2 = np.triu_indices(4, 2) +// +// Here is how they can be used with a sample array: +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Both for indexing: +// +// >>> a[iu1] +// array([ 0, 1, 2, ..., 10, 11, 15]) +// +// And for assigning values: +// +// >>> a[iu1] = -1 +// >>> a +// array([[-1, -1, -1, -1], +// [ 4, -1, -1, -1], +// [ 8, 9, -1, -1], +// [12, 13, 14, -1]]) +// +// These cover only a small part of the whole array (two diagonals right +// of the main one): +// +// >>> a[iu2] = -10 +// >>> a +// array([[ -1, -1, -10, -10], +// [ 4, -1, -1, -10], +// [ 8, 9, -1, -1], +// [ 12, 13, 14, -1]]) +// +// +// +//go:linkname TriuIndices py.triu_indices +func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Determine if a class is a subclass of a second class. +// +// `issubclass_` is equivalent to the Python built-in ``issubclass``, +// except that it returns False instead of raising a TypeError if one +// of the arguments is not a class. +// +// Parameters +// ---------- +// arg1 : class +// Input class. True is returned if `arg1` is a subclass of `arg2`. +// arg2 : class or tuple of classes. +// Input class. If a tuple of classes, True is returned if `arg1` is a +// subclass of any of the tuple elements. +// +// Returns +// ------- +// out : bool +// Whether `arg1` is a subclass of `arg2` or not. +// +// See Also +// -------- +// issubsctype, issubdtype, issctype +// +// Examples +// -------- +// >>> np.issubclass_(np.int32, int) +// False +// >>> np.issubclass_(np.int32, float) +// False +// >>> np.issubclass_(np.float64, float) +// True +// +// +// +//go:linkname Issubclass py.issubclass_ +func Issubclass(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Determine if the first argument is a subclass of the second argument. +// +// Parameters +// ---------- +// arg1, arg2 : dtype or dtype specifier +// Data-types. +// +// Returns +// ------- +// out : bool +// The result. +// +// See Also +// -------- +// issctype, issubdtype, obj2sctype +// +// Examples +// -------- +// >>> np.issubsctype('S8', str) +// False +// >>> np.issubsctype(np.array([1]), int) +// True +// >>> np.issubsctype(np.array([1]), float) +// False +// +// +// +//go:linkname Issubsctype py.issubsctype +func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Issues a DeprecationWarning, adds warning to `old_name`'s +// docstring, rebinds ``old_name.__name__`` and returns the new +// function object. +// +// This function may also be used as a decorator. +// +// Parameters +// ---------- +// func : function +// The function to be deprecated. +// old_name : str, optional +// The name of the function to be deprecated. Default is None, in +// which case the name of `func` is used. +// new_name : str, optional +// The new name for the function. Default is None, in which case the +// deprecation message is that `old_name` is deprecated. If given, the +// deprecation message is that `old_name` is deprecated and `new_name` +// should be used instead. +// message : str, optional +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. +// +// Returns +// ------- +// old_func : function +// The deprecated function. +// +// Examples +// -------- +// Note that ``olduint`` returns a value after printing Deprecation +// Warning: +// +// >>> olduint = np.deprecate(np.uint) +// DeprecationWarning: `uint64` is deprecated! # may vary +// >>> olduint(6) +// 6 +// +// +// +//go:linkname Deprecate py.deprecate +func Deprecate(__llgo_va_list ...interface{}) *py.Object +// +// Deprecates a function and includes the deprecation in its docstring. +// +// This function is used as a decorator. It returns an object that can be +// used to issue a DeprecationWarning, by passing the to-be decorated +// function as argument, this adds warning to the to-be decorated function's +// docstring and returns the new function object. +// +// See Also +// -------- +// deprecate : Decorate a function such that it issues a `DeprecationWarning` +// +// Parameters +// ---------- +// msg : str +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. +// +// Returns +// ------- +// obj : object +// +// +// +//go:linkname DeprecateWithDoc py.deprecate_with_doc +func DeprecateWithDoc(msg *py.Object) *py.Object +// +// Return the directory that contains the NumPy \*.h header files. +// +// Extension modules that need to compile against NumPy should use this +// function to locate the appropriate include directory. +// +// Notes +// ----- +// When using ``distutils``, for example in ``setup.py``:: +// +// import numpy as np +// ... +// Extension('extension_name', ... +// include_dirs=[np.get_include()]) +// ... +// +// +// +//go:linkname GetInclude py.get_include +func GetInclude() *py.Object +// +// Get help information for an array, function, class, or module. +// +// Parameters +// ---------- +// object : object or str, optional +// Input object or name to get information about. If `object` is +// an `ndarray` instance, information about the array is printed. +// If `object` is a numpy object, its docstring is given. If it is +// a string, available modules are searched for matching objects. +// If None, information about `info` itself is returned. +// maxwidth : int, optional +// Printing width. +// output : file like object, optional +// File like object that the output is written to, default is +// ``None``, in which case ``sys.stdout`` will be used. +// The object has to be opened in 'w' or 'a' mode. +// toplevel : str, optional +// Start search at this level. +// +// See Also +// -------- +// source, lookfor +// +// Notes +// ----- +// When used interactively with an object, ``np.info(obj)`` is equivalent +// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython +// prompt. +// +// Examples +// -------- +// >>> np.info(np.polyval) # doctest: +SKIP +// polyval(p, x) +// Evaluate the polynomial p at x. +// ... +// +// When using a string for `object` it is possible to get multiple results. +// +// >>> np.info('fft') # doctest: +SKIP +// *** Found in numpy *** +// Core FFT routines +// ... +// *** Found in numpy.fft *** +// fft(a, n=None, axis=-1) +// ... +// *** Repeat reference found in numpy.fft.fftpack *** +// *** Total of 3 references found. *** +// +// When the argument is an array, information about the array is printed. +// +// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) +// >>> np.info(a) +// class: ndarray +// shape: (2, 3) +// strides: (24, 8) +// itemsize: 8 +// aligned: True +// contiguous: True +// fortran: False +// data pointer: 0x562b6e0d2860 # may vary +// byteorder: little +// byteswap: False +// type: complex64 +// +// +// +//go:linkname Info py.info +func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object +// +// Print or write to a file the source code for a NumPy object. +// +// The source code is only returned for objects written in Python. Many +// functions and classes are defined in C and will therefore not return +// useful information. +// +// Parameters +// ---------- +// object : numpy object +// Input object. This can be any object (function, class, module, +// ...). +// output : file object, optional +// If `output` not supplied then source code is printed to screen +// (sys.stdout). File object must be created with either write 'w' or +// append 'a' modes. +// +// See Also +// -------- +// lookfor, info +// +// Examples +// -------- +// >>> np.source(np.interp) #doctest: +SKIP +// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py +// def interp(x, xp, fp, left=None, right=None): +// """.... (full docstring printed)""" +// if isinstance(x, (float, int, number)): +// return compiled_interp([x], xp, fp, left, right).item() +// else: +// return compiled_interp(x, xp, fp, left, right) +// +// The source code is only returned for objects written in Python. +// +// >>> np.source(np.array) #doctest: +SKIP +// Not available for this object. +// +// +// +//go:linkname Source py.source +func Source(object *py.Object, output *py.Object) *py.Object +// +// Print the NumPy arrays in the given dictionary. +// +// If there is no dictionary passed in or `vardict` is None then returns +// NumPy arrays in the globals() dictionary (all NumPy arrays in the +// namespace). +// +// Parameters +// ---------- +// vardict : dict, optional +// A dictionary possibly containing ndarrays. Default is globals(). +// +// Returns +// ------- +// out : None +// Returns 'None'. +// +// Notes +// ----- +// Prints out the name, shape, bytes and type of all of the ndarrays +// present in `vardict`. +// +// Examples +// -------- +// >>> a = np.arange(10) +// >>> b = np.ones(20) +// >>> np.who() +// Name Shape Bytes Type +// =========================================================== +// a 10 80 int64 +// b 20 160 float64 +// Upper bound on total bytes = 240 +// +// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', +// ... 'idx':5} +// >>> np.who(d) +// Name Shape Bytes Type +// =========================================================== +// x 2 16 float64 +// y 3 24 float64 +// Upper bound on total bytes = 40 +// +// +// +//go:linkname Who py.who +func Who(vardict *py.Object) *py.Object +// +// Do a keyword search on docstrings. +// +// A list of objects that matched the search is displayed, +// sorted by relevance. All given keywords need to be found in the +// docstring for it to be returned as a result, but the order does +// not matter. +// +// Parameters +// ---------- +// what : str +// String containing words to look for. +// module : str or list, optional +// Name of module(s) whose docstrings to go through. +// import_modules : bool, optional +// Whether to import sub-modules in packages. Default is True. +// regenerate : bool, optional +// Whether to re-generate the docstring cache. Default is False. +// output : file-like, optional +// File-like object to write the output to. If omitted, use a pager. +// +// See Also +// -------- +// source, info +// +// Notes +// ----- +// Relevance is determined only roughly, by checking if the keywords occur +// in the function name, at the start of a docstring, etc. +// +// Examples +// -------- +// >>> np.lookfor('binary representation') # doctest: +SKIP +// Search results for 'binary representation' +// ------------------------------------------ +// numpy.binary_repr +// Return the binary representation of the input number as a string. +// numpy.core.setup_common.long_double_representation +// Given a binary dump as given by GNU od -b, look for long double +// numpy.base_repr +// Return a string representation of a number in the given base system. +// ... +// +// +// +//go:linkname Lookfor py.lookfor +func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object +// +// Returns pointers to the end-points of an array. +// +// Parameters +// ---------- +// a : ndarray +// Input array. It must conform to the Python-side of the array +// interface. +// +// Returns +// ------- +// (low, high) : tuple of 2 integers +// The first integer is the first byte of the array, the second +// integer is just past the last byte of the array. If `a` is not +// contiguous it will not use every byte between the (`low`, `high`) +// values. +// +// Examples +// -------- +// >>> I = np.eye(2, dtype='f'); I.dtype +// dtype('float32') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// >>> I = np.eye(2); I.dtype +// dtype('float64') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// +// +// +//go:linkname ByteBounds py.byte_bounds +func ByteBounds(a *py.Object) *py.Object +// +// Protected string evaluation. +// +// Evaluate a string containing a Python literal expression without +// allowing the execution of arbitrary non-literal code. +// +// .. warning:: +// +// This function is identical to :py:meth:`ast.literal_eval` and +// has the same security implications. It may not always be safe +// to evaluate large input strings. +// +// Parameters +// ---------- +// source : str +// The string to evaluate. +// +// Returns +// ------- +// obj : object +// The result of evaluating `source`. +// +// Raises +// ------ +// SyntaxError +// If the code has invalid Python syntax, or if it contains +// non-literal code. +// +// Examples +// -------- +// >>> np.safe_eval('1') +// 1 +// >>> np.safe_eval('[1, 2, 3]') +// [1, 2, 3] +// >>> np.safe_eval('{"foo": ("bar", 10.0)}') +// {'foo': ('bar', 10.0)} +// +// >>> np.safe_eval('import os') +// Traceback (most recent call last): +// ... +// SyntaxError: invalid syntax +// +// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') +// Traceback (most recent call last): +// ... +// ValueError: malformed node or string: <_ast.Call object at 0x...> +// +// +// +//go:linkname SafeEval py.safe_eval +func SafeEval(source *py.Object) *py.Object +// +// Print information about various resources in the system +// including available intrinsic support and BLAS/LAPACK library +// in use +// +// .. versionadded:: 1.24.0 +// +// See Also +// -------- +// show_config : Show libraries in the system on which NumPy was built. +// +// Notes +// ----- +// 1. Information is derived with the help of `threadpoolctl `_ +// library if available. +// 2. SIMD related information is derived from ``__cpu_features__``, +// ``__cpu_baseline__`` and ``__cpu_dispatch__`` +// +// +// +//go:linkname ShowRuntime py.show_runtime +func ShowRuntime() *py.Object +// +// Load data from a text file. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : data-type, optional +// Data-type of the resulting array; default: float. If this is a +// structured data-type, the resulting array will be 1-dimensional, and +// each row will be interpreted as an element of the array. In this +// case, the number of columns used must match the number of fields in +// the data-type. +// comments : str or sequence of str or None, optional +// The characters or list of characters used to indicate the start of a +// comment. None implies no comments. For backwards compatibility, byte +// strings will be decoded as 'latin1'. The default is '#'. +// delimiter : str, optional +// The character used to separate the values. For backwards compatibility, +// byte strings will be decoded as 'latin1'. The default is whitespace. +// +// .. versionchanged:: 1.23.0 +// Only single character delimiters are supported. Newline characters +// cannot be used as the delimiter. +// +// converters : dict or callable, optional +// Converter functions to customize value parsing. If `converters` is +// callable, the function is applied to all columns, else it must be a +// dict that maps column number to a parser function. +// See examples for further details. +// Default: None. +// +// .. versionchanged:: 1.23.0 +// The ability to pass a single callable to be applied to all columns +// was added. +// +// skiprows : int, optional +// Skip the first `skiprows` lines, including comments; default: 0. +// usecols : int or sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. +// The default, None, results in all columns being read. +// +// .. versionchanged:: 1.11.0 +// When a single column has to be read it is possible to use +// an integer instead of a tuple. E.g ``usecols = 3`` reads the +// fourth column the same way as ``usecols = (3,)`` would. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = loadtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// ndmin : int, optional +// The returned array will have at least `ndmin` dimensions. +// Otherwise mono-dimensional axes will be squeezed. +// Legal values: 0 (default), 1 or 2. +// +// .. versionadded:: 1.6.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply to input streams. +// The special value 'bytes' enables backward compatibility workarounds +// that ensures you receive byte arrays as results if possible and passes +// 'latin1' encoded strings to converters. Override this value to receive +// unicode arrays and pass strings as input to converters. If set to None +// the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// max_rows : int, optional +// Read `max_rows` rows of content after `skiprows` lines. The default is +// to read all the rows. Note that empty rows containing no data such as +// empty lines and comment lines are not counted towards `max_rows`, +// while such lines are counted in `skiprows`. +// +// .. versionadded:: 1.16.0 +// +// .. versionchanged:: 1.23.0 +// Lines containing no data, including comment lines (e.g., lines +// starting with '#' or as specified via `comments`) are not counted +// towards `max_rows`. +// quotechar : unicode character or None, optional +// The character used to denote the start and end of a quoted item. +// Occurrences of the delimiter or comment characters are ignored within +// a quoted item. The default value is ``quotechar=None``, which means +// quoting support is disabled. +// +// If two consecutive instances of `quotechar` are found within a quoted +// field, the first is treated as an escape character. See examples. +// +// .. versionadded:: 1.23.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Data read from the text file. +// +// See Also +// -------- +// load, fromstring, fromregex +// genfromtxt : Load data with missing values handled as specified. +// scipy.io.loadmat : reads MATLAB data files +// +// Notes +// ----- +// This function aims to be a fast reader for simply formatted files. The +// `genfromtxt` function provides more sophisticated handling of, e.g., +// lines with missing values. +// +// Each row in the input text file must have the same number of values to be +// able to read all values. If all rows do not have same number of values, a +// subset of up to n columns (where n is the least number of values present +// in all rows) can be read by specifying the columns via `usecols`. +// +// .. versionadded:: 1.10.0 +// +// The strings produced by the Python float.hex method can be used as +// input for floats. +// +// Examples +// -------- +// >>> from io import StringIO # StringIO behaves like a file object +// >>> c = StringIO("0 1\n2 3") +// >>> np.loadtxt(c) +// array([[0., 1.], +// [2., 3.]]) +// +// >>> d = StringIO("M 21 72\nF 35 58") +// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), +// ... 'formats': ('S1', 'i4', 'f4')}) +// array([(b'M', 21, 72.), (b'F', 35, 58.)], +// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") +// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) +// >>> x +// array([1., 3.]) +// >>> y +// array([2., 4.]) +// +// The `converters` argument is used to specify functions to preprocess the +// text prior to parsing. `converters` can be a dictionary that maps +// preprocessing functions to each column: +// +// >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n") +// >>> conv = { +// ... 0: lambda x: np.floor(float(x)), # conversion fn for column 0 +// ... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1 +// ... } +// >>> np.loadtxt(s, delimiter=",", converters=conv) +// array([[1., 3.], +// [3., 5.]]) +// +// `converters` can be a callable instead of a dictionary, in which case it +// is applied to all columns: +// +// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") +// >>> import functools +// >>> conv = functools.partial(int, base=16) +// >>> np.loadtxt(s, converters=conv) +// array([[222., 173.], +// [192., 222.]]) +// +// This example shows how `converters` can be used to convert a field +// with a trailing minus sign into a negative number. +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> def conv(fld): +// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) +// ... +// >>> np.loadtxt(s, converters=conv) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Using a callable as the converter can be particularly useful for handling +// values with different formatting, e.g. floats with underscores: +// +// >>> s = StringIO("1 2.7 100_000") +// >>> np.loadtxt(s, converters=float) +// array([1.e+00, 2.7e+00, 1.e+05]) +// +// This idea can be extended to automatically handle values specified in +// many different formats: +// +// >>> def conv(val): +// ... try: +// ... return float(val) +// ... except ValueError: +// ... return float.fromhex(val) +// >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2") +// >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None) +// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) +// +// Note that with the default ``encoding="bytes"``, the inputs to the +// converter function are latin-1 encoded byte strings. To deactivate the +// implicit encoding prior to conversion, use ``encoding=None`` +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x) +// >>> np.loadtxt(s, converters=conv, encoding=None) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Support for quoted fields is enabled with the `quotechar` parameter. +// Comment and delimiter characters are ignored when they appear within a +// quoted item delineated by `quotechar`: +// +// >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// dtype=[('label', '>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"') +// >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"') +// array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20") +// >>> np.loadtxt(d, usecols=(0, 1)) +// array([[ 1., 2.], +// [ 2., 4.], +// [ 3., 9.], +// [ 4., 16.]]) +// +// +// +//go:linkname Loadtxt py.loadtxt +func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object +// +// Load data from a text file, with missing values handled as specified. +// +// Each line past the first `skip_header` lines is split at the `delimiter` +// character, and characters following the `comments` character are discarded. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : dtype, optional +// Data type of the resulting array. +// If None, the dtypes will be determined by the contents of each +// column, individually. +// comments : str, optional +// The character used to indicate the start of a comment. +// All the characters occurring on a line after a comment are discarded. +// delimiter : str, int, or sequence, optional +// The string used to separate values. By default, any consecutive +// whitespaces act as delimiter. An integer or sequence of integers +// can also be provided as width(s) of each field. +// skiprows : int, optional +// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. +// skip_header : int, optional +// The number of lines to skip at the beginning of the file. +// skip_footer : int, optional +// The number of lines to skip at the end of the file. +// converters : variable, optional +// The set of functions that convert the data of a column to a value. +// The converters can also be used to provide a default value +// for missing data: ``converters = {3: lambda s: float(s or 0)}``. +// missing : variable, optional +// `missing` was removed in numpy 1.10. Please use `missing_values` +// instead. +// missing_values : variable, optional +// The set of strings corresponding to missing data. +// filling_values : variable, optional +// The set of values to be used as default when the data are missing. +// usecols : sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. +// names : {None, True, str, sequence}, optional +// If `names` is True, the field names are read from the first line after +// the first `skip_header` lines. This line can optionally be preceded +// by a comment delimiter. If `names` is a sequence or a single-string of +// comma-separated names, the names will be used to define the field names +// in a structured dtype. If `names` is None, the names of the dtype +// fields will be used, if any. +// excludelist : sequence, optional +// A list of names to exclude. This list is appended to the default list +// ['return','file','print']. Excluded names are appended with an +// underscore: for example, `file` would become `file_`. +// deletechars : str, optional +// A string combining invalid characters that must be deleted from the +// names. +// defaultfmt : str, optional +// A format used to define default field names, such as "f%i" or "f_%02i". +// autostrip : bool, optional +// Whether to automatically strip white spaces from the variables. +// replace_space : char, optional +// Character(s) used in replacement of white spaces in the variable +// names. By default, use a '_'. +// case_sensitive : {True, False, 'upper', 'lower'}, optional +// If True, field names are case sensitive. +// If False or 'upper', field names are converted to upper case. +// If 'lower', field names are converted to lower case. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = genfromtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// usemask : bool, optional +// If True, return a masked array. +// If False, return a regular array. +// loose : bool, optional +// If True, do not raise errors for invalid values. +// invalid_raise : bool, optional +// If True, an exception is raised if an inconsistency is detected in the +// number of columns. +// If False, a warning is emitted and the offending lines are skipped. +// max_rows : int, optional +// The maximum number of rows to read. Must not be used with skip_footer +// at the same time. If given, the value must be at least 1. Default is +// to read the entire file. +// +// .. versionadded:: 1.10.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply when `fname` is +// a file object. The special value 'bytes' enables backward compatibility +// workarounds that ensure that you receive byte arrays when possible +// and passes latin1 encoded strings to converters. Override this value to +// receive unicode arrays and pass strings as input to converters. If set +// to None the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// ndmin : int, optional +// Same parameter as `loadtxt` +// +// .. versionadded:: 1.23.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Data read from the text file. If `usemask` is True, this is a +// masked array. +// +// See Also +// -------- +// numpy.loadtxt : equivalent function when no data is missing. +// +// Notes +// ----- +// * When spaces are used as delimiters, or when no delimiter has been given +// as input, there should not be any missing data between two fields. +// * When the variables are named (either by a flexible dtype or with `names`), +// there must not be any header in the file (else a ValueError +// exception is raised). +// * Individual values are not stripped of spaces by default. +// When using a custom converter, make sure the function does remove spaces. +// +// References +// ---------- +// .. [1] NumPy User Guide, section `I/O with NumPy +// `_. +// +// Examples +// -------- +// >>> from io import StringIO +// >>> import numpy as np +// +// Comma delimited file with mixed dtype +// +// >>> s = StringIO(u"1,1.3,abcde") +// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), +// ... ('mystring','S5')], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only +// >>> data = np.genfromtxt(s, dtype=None, +// ... names = ['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) +// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", +// ... names=['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> s = StringIO(u"11.3abcde") +// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], +// ... delimiter=[1,3,5]) +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('intvar', '>> f = StringIO(''' +// ... text,# of chars +// ... hello world,11 +// ... numpy,5''') +// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') +// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], +// dtype=[('f0', 'S12'), ('f1', 'S12')]) +// +// +// +//go:linkname Genfromtxt py.genfromtxt +func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object +// +// Load ASCII data from a file and return it in a record array. +// +// If ``usemask=False`` a standard `recarray` is returned, +// if ``usemask=True`` a MaskedRecords array is returned. +// +// Parameters +// ---------- +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromtxt py.recfromtxt +func Recfromtxt(fname *py.Object) *py.Object +// +// Load ASCII data stored in a comma-separated file. +// +// The returned array is a record array (if ``usemask=False``, see +// `recarray`) or a masked record array (if ``usemask=True``, +// see `ma.mrecords.MaskedRecords`). +// +// Parameters +// ---------- +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function to load ASCII data. +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromcsv py.recfromcsv +func Recfromcsv(fname *py.Object) *py.Object +// +// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. +// +// .. warning:: Loading files that contain object arrays uses the ``pickle`` +// module, which is not secure against erroneous or maliciously +// constructed data. Consider passing ``allow_pickle=False`` to +// load data that is known not to contain object arrays for the +// safer handling of untrusted sources. +// +// Parameters +// ---------- +// file : file-like object, string, or pathlib.Path +// The file to read. File-like objects must support the +// ``seek()`` and ``read()`` methods and must always +// be opened in binary mode. Pickled files require that the +// file-like object support the ``readline()`` method as well. +// mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional +// If not None, then memory-map the file, using the given mode (see +// `numpy.memmap` for a detailed description of the modes). A +// memory-mapped array is kept on disk. However, it can be accessed +// and sliced like any ndarray. Memory mapping is especially useful +// for accessing small fragments of large files without reading the +// entire file into memory. +// allow_pickle : bool, optional +// Allow loading pickled object arrays stored in npy files. Reasons for +// disallowing pickles include security, as loading pickled data can +// execute arbitrary code. If pickles are disallowed, loading object +// arrays will fail. Default: False +// +// .. versionchanged:: 1.16.3 +// Made default False in response to CVE-2019-6446. +// +// fix_imports : bool, optional +// Only useful when loading Python 2 generated pickled files on Python 3, +// which includes npy/npz files containing object arrays. If `fix_imports` +// is True, pickle will try to map the old Python 2 names to the new names +// used in Python 3. +// encoding : str, optional +// What encoding to use when reading Python 2 strings. Only useful when +// loading Python 2 generated pickled files in Python 3, which includes +// npy/npz files containing object arrays. Values other than 'latin1', +// 'ASCII', and 'bytes' are not allowed, as they can corrupt numerical +// data. Default: 'ASCII' +// max_header_size : int, optional +// Maximum allowed size of the header. Large headers may not be safe +// to load securely and thus require explicitly passing a larger value. +// See :py:func:`ast.literal_eval()` for details. +// This option is ignored when `allow_pickle` is passed. In that case +// the file is by definition trusted and the limit is unnecessary. +// +// Returns +// ------- +// result : array, tuple, dict, etc. +// Data stored in the file. For ``.npz`` files, the returned instance +// of NpzFile class must be closed to avoid leaking file descriptors. +// +// Raises +// ------ +// OSError +// If the input file does not exist or cannot be read. +// UnpicklingError +// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. +// ValueError +// The file contains an object array, but ``allow_pickle=False`` given. +// EOFError +// When calling ``np.load`` multiple times on the same file handle, +// if all data has already been read +// +// See Also +// -------- +// save, savez, savez_compressed, loadtxt +// memmap : Create a memory-map to an array stored in a file on disk. +// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. +// +// Notes +// ----- +// - If the file contains pickle data, then whatever object is stored +// in the pickle is returned. +// - If the file is a ``.npy`` file, then a single array is returned. +// - If the file is a ``.npz`` file, then a dictionary-like object is +// returned, containing ``{filename: array}`` key-value pairs, one for +// each file in the archive. +// - If the file is a ``.npz`` file, the returned value supports the +// context manager protocol in a similar fashion to the open function:: +// +// with load('foo.npz') as data: +// a = data['a'] +// +// The underlying file descriptor is closed when exiting the 'with' +// block. +// +// Examples +// -------- +// Store data to disk, and load it again: +// +// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) +// >>> np.load('/tmp/123.npy') +// array([[1, 2, 3], +// [4, 5, 6]]) +// +// Store compressed data to disk, and load it again: +// +// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) +// >>> b=np.array([1, 2]) +// >>> np.savez('/tmp/123.npz', a=a, b=b) +// >>> data = np.load('/tmp/123.npz') +// >>> data['a'] +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> data['b'] +// array([1, 2]) +// >>> data.close() +// +// Mem-map the stored array, and then access the second row +// directly from disk: +// +// >>> X = np.load('/tmp/123.npy', mmap_mode='r') +// >>> X[1, :] +// memmap([4, 5, 6]) +// +// +// +//go:linkname Load py.load +func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object +// +// Build a matrix object from a string, nested sequence, or array. +// +// Parameters +// ---------- +// obj : str or array_like +// Input data. If a string, variables in the current scope may be +// referenced by name. +// ldict : dict, optional +// A dictionary that replaces local operands in current frame. +// Ignored if `obj` is not a string or `gdict` is None. +// gdict : dict, optional +// A dictionary that replaces global operands in current frame. +// Ignored if `obj` is not a string. +// +// Returns +// ------- +// out : matrix +// Returns a matrix object, which is a specialized 2-D array. +// +// See Also +// -------- +// block : +// A generalization of this function for N-d arrays, that returns normal +// ndarrays. +// +// Examples +// -------- +// >>> A = np.mat('1 1; 1 1') +// >>> B = np.mat('2 2; 2 2') +// >>> C = np.mat('3 4; 5 6') +// >>> D = np.mat('7 8; 9 0') +// +// All the following expressions construct the same block matrix: +// +// >>> np.bmat([[A, B], [C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat('A,B; C,D') +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// +// +// +//go:linkname Bmat py.bmat +func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. +// +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Mat py.mat +func Mat(data *py.Object, dtype *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. +// +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Asmatrix py.asmatrix +func Asmatrix(data *py.Object, dtype *py.Object) *py.Object +// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the absolute value element-wise. +// +// ``np.abs`` is a shorthand for this function. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// absolute : ndarray +// An ndarray containing the absolute value of +// each element in `x`. For complex input, ``a + ib``, the +// absolute value is :math:`\sqrt{ a^2 + b^2 }`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> x = np.array([-1.2, 1.2]) +// >>> np.absolute(x) +// array([ 1.2, 1.2]) +// >>> np.absolute(1.2 + 1j) +// 1.5620499351813308 +// +// Plot the function over ``[-10, 10]``: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(start=-10, stop=10, num=101) +// >>> plt.plot(x, np.absolute(x)) +// >>> plt.show() +// +// Plot the function over the complex plane: +// +// >>> xx = x + 1j * x[:, np.newaxis] +// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') +// >>> plt.show() +// +// The `abs` function can be used as a shorthand for ``np.absolute`` on +// ndarrays. +// +// >>> x = np.array([-1.2, 1.2]) +// >>> abs(x) +// array([1.2, 1.2]) +// +//go:linkname Abs py.abs +func Abs(__llgo_va_list ...interface{}) *py.Object diff --git a/numpy_1/numpy_autogen_link.go b/numpy_1/numpy_autogen_link.go new file mode 100644 index 00000000..bb5882ce --- /dev/null +++ b/numpy_1/numpy_autogen_link.go @@ -0,0 +1,5 @@ +package numpy + +import _ "github.com/goplus/lib/py" + +// LLGoPackage is defined in the main binding file From 79278bf633865e6fe147aa862ffb566a09775dfc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Fri, 15 Aug 2025 10:05:32 +0800 Subject: [PATCH 10/13] delect --- math/_demo/go.mod | 10 - math/_demo/go.sum | 2 - math/_demo/main.go | 29 - math/go.mod | 5 - math/go.sum | 2 - math/llpkg.cfg | 16 - math/llpyg.cfg | 123 - math/math.go | 276 - math/math_autogen_link.go | 5 - math4/_demo/go.mod | 10 - math4/_demo/go.sum | 2 - math4/_demo/main.go | 29 - math4/go.mod | 5 - math4/llpkg.cfg | 16 - math4/llpyg.cfg | 123 - math4/math.go | 280 - math4/math_autogen_link.go | 5 - math5/_demo/go.mod | 10 - math5/_demo/go.sum | 2 - math5/_demo/main.go | 29 - math5/go.mod | 5 - math5/llpkg.cfg | 16 - math5/llpyg.cfg | 123 - math5/math.go | 280 - math5/math_autogen_link.go | 5 - math6/_demo/go.mod | 10 - math6/_demo/go.sum | 2 - math6/_demo/main.go | 29 - math6/go.mod | 5 - math6/llpkg.cfg | 16 - math6/llpyg.cfg | 123 - math6/math.go | 280 - math6/math_autogen_link.go | 5 - numpy/_demo/go.mod | 10 - numpy/_demo/go.sum | 2 - numpy/_demo/main.go | 11 - numpy/go.mod | 5 - numpy/go.sum | 2 - numpy/llpkg.cfg | 16 - numpy/llpyg.cfg | 155 - numpy/numpy.go | 9589 --------------------------------- numpy/numpy_autogen_link.go | 5 - numpy_1/_demo/go.mod | 10 - numpy_1/_demo/go.sum | 2 - numpy_1/_demo/main.go | 11 - numpy_1/go.mod | 5 - numpy_1/go.sum | 2 - numpy_1/llpkg.cfg | 16 - numpy_1/llpyg.cfg | 155 - numpy_1/numpy.go | 9589 --------------------------------- numpy_1/numpy_autogen_link.go | 5 - 51 files changed, 21468 deletions(-) delete mode 100644 math/_demo/go.mod delete mode 100644 math/_demo/go.sum delete mode 100644 math/_demo/main.go delete mode 100644 math/go.mod delete mode 100644 math/go.sum delete mode 100644 math/llpkg.cfg delete mode 100644 math/llpyg.cfg delete mode 100644 math/math.go delete mode 100644 math/math_autogen_link.go delete mode 100644 math4/_demo/go.mod delete mode 100644 math4/_demo/go.sum delete mode 100644 math4/_demo/main.go delete mode 100644 math4/go.mod delete mode 100644 math4/llpkg.cfg delete mode 100644 math4/llpyg.cfg delete mode 100644 math4/math.go delete mode 100644 math4/math_autogen_link.go delete mode 100644 math5/_demo/go.mod delete mode 100644 math5/_demo/go.sum delete mode 100644 math5/_demo/main.go delete mode 100644 math5/go.mod delete mode 100644 math5/llpkg.cfg delete mode 100644 math5/llpyg.cfg delete mode 100644 math5/math.go delete mode 100644 math5/math_autogen_link.go delete mode 100644 math6/_demo/go.mod delete mode 100644 math6/_demo/go.sum delete mode 100644 math6/_demo/main.go delete mode 100644 math6/go.mod delete mode 100644 math6/llpkg.cfg delete mode 100644 math6/llpyg.cfg delete mode 100644 math6/math.go delete mode 100644 math6/math_autogen_link.go delete mode 100644 numpy/_demo/go.mod delete mode 100644 numpy/_demo/go.sum delete mode 100644 numpy/_demo/main.go delete mode 100644 numpy/go.mod delete mode 100644 numpy/go.sum delete mode 100644 numpy/llpkg.cfg delete mode 100644 numpy/llpyg.cfg delete mode 100644 numpy/numpy.go delete mode 100644 numpy/numpy_autogen_link.go delete mode 100644 numpy_1/_demo/go.mod delete mode 100644 numpy_1/_demo/go.sum delete mode 100644 numpy_1/_demo/main.go delete mode 100644 numpy_1/go.mod delete mode 100644 numpy_1/go.sum delete mode 100644 numpy_1/llpkg.cfg delete mode 100644 numpy_1/llpyg.cfg delete mode 100644 numpy_1/numpy.go delete mode 100644 numpy_1/numpy_autogen_link.go diff --git a/math/_demo/go.mod b/math/_demo/go.mod deleted file mode 100644 index 46f5f92f..00000000 --- a/math/_demo/go.mod +++ /dev/null @@ -1,10 +0,0 @@ -module test_math3 - -go 1.24.5 - -replace github.com/goplus/llpkg/math => ../ - -require ( - github.com/goplus/lib v0.2.0 - github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 -) diff --git a/math/_demo/go.sum b/math/_demo/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/math/_demo/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math/_demo/main.go b/math/_demo/main.go deleted file mode 100644 index 023355a1..00000000 --- a/math/_demo/main.go +++ /dev/null @@ -1,29 +0,0 @@ -package main - -import ( - "github.com/goplus/lib/py" - "github.com/goplus/lib/py/std" - "github.com/goplus/llpkg/math" -) - -func main() { - // 初始化 Python - py.Initialize() - defer py.Finalize() - - // 测试 math.Sqrt - result1 := math.Sqrt(py.Float(4.0)) - std.Print(py.Str("sqrt(4) = "), result1) - - // 测试 math.Cos - result2 := math.Cos(py.Float(0.0)) - std.Print(py.Str("cos(0) = "), result2) - - // 测试 math.Pow - result3 := math.Pow(py.Float(2.0), py.Float(3.0)) - std.Print(py.Str("2^3 = "), result3) - - // 测试 math.Sin - result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 - std.Print(py.Str("sin(1.57) = "), result4) -} diff --git a/math/go.mod b/math/go.mod deleted file mode 100644 index 7d6e6402..00000000 --- a/math/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/goplus/llpkg/math - -go 1.23 - -require github.com/goplus/lib v0.2.0 diff --git a/math/go.sum b/math/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/math/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math/llpkg.cfg b/math/llpkg.cfg deleted file mode 100644 index dd565d41..00000000 --- a/math/llpkg.cfg +++ /dev/null @@ -1,16 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "python_version": "3.12", - "index_url": "https://pypi.org/simple/" - } - }, - "package": { - "name": "math", - "version": "builtin" - } - } -} \ No newline at end of file diff --git a/math/llpyg.cfg b/math/llpyg.cfg deleted file mode 100644 index 94275e92..00000000 --- a/math/llpyg.cfg +++ /dev/null @@ -1,123 +0,0 @@ -{ - "name": "math", - "module": "math", - "python": true, - "symMap": { - "abs": "Abs", - "acos": "Acos", - "acosh": "Acosh", - "all": "All", - "any": "Any", - "asin": "Asin", - "asinh": "Asinh", - "atan": "Atan", - "atan2": "Atan2", - "atanh": "Atanh", - "bin": "Bin", - "bool": "Bool", - "cbrt": "Cbrt", - "ceil": "Ceil", - "chr": "Chr", - "comb": "Comb", - "copysign": "Copysign", - "cos": "Cos", - "cosh": "Cosh", - "degrees": "Degrees", - "dict": "Dict", - "dir": "Dir", - "dist": "Dist", - "enumerate": "Enumerate", - "erf": "Erf", - "erfc": "Erfc", - "exp": "Exp", - "exp2": "Exp2", - "expm1": "Expm1", - "fabs": "Fabs", - "factorial": "Factorial", - "filter": "Filter", - "float": "Float", - "floor": "Floor", - "fmod": "Fmod", - "format": "Format", - "frexp": "Frexp", - "frozenset": "FrozenSet", - "fsum": "Fsum", - "gamma": "Gamma", - "gcd": "Gcd", - "getattr": "GetAttr", - "hasattr": "HasAttr", - "hash": "Hash", - "help": "Help", - "hex": "Hex", - "id": "ID", - "input": "Input", - "int": "Int", - "isinstance": "IsInstance", - "issubclass": "IsSubclass", - "iter": "Iter", - "len": "Len", - "list": "List", - "locals": "Locals", - "log10": "Log10", - "log2": "Log2", - "map": "Map", - "max": "Max", - "min": "Min", - "modf": "Modf", - "next": "Next", - "nextafter": "Nextafter", - "oct": "Oct", - "open": "Open", - "ord": "Ord", - "perm": "Perm", - "pow": "Pow", - "print": "Print", - "prod": "Prod", - "radians": "Radians", - "range": "Range", - "remainder": "Remainder", - "repr": "Repr", - "reversed": "Reversed", - "round": "Round", - "set": "Set", - "setattr": "SetAttr", - "sin": "Sin", - "sinh": "Sinh", - "sorted": "Sorted", - "sqrt": "Sqrt", - "str": "Str", - "sum": "Sum", - "sumprod": "Sumprod", - "tan": "Tan", - "tanh": "Tanh", - "trunc": "Trunc", - "tuple": "Tuple", - "type": "Type", - "ulp": "Ulp", - "vars": "Vars", - "zip": "Zip" - }, - "deps": [ - "py" - ], - "include": [ - "math" - ], - "exclude": [ - "__builtins__", - "__cached__", - "__doc__", - "__file__", - "__loader__", - "__name__", - "__package__", - "__spec__" - ], - "constants": { - "e": "E", - "inf": "Inf", - "nan": "NaN", - "pi": "Pi", - "tau": "Tau" - } -} \ No newline at end of file diff --git a/math/math.go b/math/math.go deleted file mode 100644 index 4d1b43de..00000000 --- a/math/math.go +++ /dev/null @@ -1,276 +0,0 @@ -package math - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -const LLGoPackage = "py.math" -// Return the arc cosine (measured in radians) of x. -// -// The result is between 0 and pi. -// -//go:linkname Acos py.acos -func Acos(x *py.Object) *py.Object -// Return the inverse hyperbolic cosine of x. -// -//go:linkname Acosh py.acosh -func Acosh(x *py.Object) *py.Object -// Return the arc sine (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Asin py.asin -func Asin(x *py.Object) *py.Object -// Return the inverse hyperbolic sine of x. -// -//go:linkname Asinh py.asinh -func Asinh(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Atan py.atan -func Atan(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of y/x. -// -// Unlike atan(y/x), the signs of both x and y are considered. -// -//go:linkname Atan2 py.atan2 -func Atan2(y *py.Object, x *py.Object) *py.Object -// Return the inverse hyperbolic tangent of x. -// -//go:linkname Atanh py.atanh -func Atanh(x *py.Object) *py.Object -// Return the cube root of x. -// -//go:linkname Cbrt py.cbrt -func Cbrt(x *py.Object) *py.Object -// Return the ceiling of x as an Integral. -// -// This is the smallest integer >= x. -// -//go:linkname Ceil py.ceil -func Ceil(x *py.Object) *py.Object -// Return a float with the magnitude (absolute value) of x but the sign of y. -// -// On platforms that support signed zeros, copysign(1.0, -0.0) -// returns -1.0. -// -// -//go:linkname Copysign py.copysign -func Copysign(x *py.Object, y *py.Object) *py.Object -// Return the cosine of x (measured in radians). -// -//go:linkname Cos py.cos -func Cos(x *py.Object) *py.Object -// Return the hyperbolic cosine of x. -// -//go:linkname Cosh py.cosh -func Cosh(x *py.Object) *py.Object -// Convert angle x from radians to degrees. -// -//go:linkname Degrees py.degrees -func Degrees(x *py.Object) *py.Object -// Return the Euclidean distance between two points p and q. -// -// The points should be specified as sequences (or iterables) of -// coordinates. Both inputs must have the same dimension. -// -// Roughly equivalent to: -// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) -// -//go:linkname Dist py.dist -func Dist(p *py.Object, q *py.Object) *py.Object -// Error function at x. -// -//go:linkname Erf py.erf -func Erf(x *py.Object) *py.Object -// Complementary error function at x. -// -//go:linkname Erfc py.erfc -func Erfc(x *py.Object) *py.Object -// Return e raised to the power of x. -// -//go:linkname Exp py.exp -func Exp(x *py.Object) *py.Object -// Return 2 raised to the power of x. -// -//go:linkname Exp2 py.exp2 -func Exp2(x *py.Object) *py.Object -// Return exp(x)-1. -// -// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. -// -//go:linkname Expm1 py.expm1 -func Expm1(x *py.Object) *py.Object -// Return the absolute value of the float x. -// -//go:linkname Fabs py.fabs -func Fabs(x *py.Object) *py.Object -// Find n!. -// -// Raise a ValueError if x is negative or non-integral. -// -//go:linkname Factorial py.factorial -func Factorial(n *py.Object) *py.Object -// Return the floor of x as an Integral. -// -// This is the largest integer <= x. -// -//go:linkname Floor py.floor -func Floor(x *py.Object) *py.Object -// Return fmod(x, y), according to platform C. -// -// x % y may differ. -// -//go:linkname Fmod py.fmod -func Fmod(x *py.Object, y *py.Object) *py.Object -// Return the mantissa and exponent of x, as pair (m, e). -// -// m is a float and e is an int, such that x = m * 2.**e. -// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. -// -//go:linkname Frexp py.frexp -func Frexp(x *py.Object) *py.Object -// Return an accurate floating-point sum of values in the iterable seq. -// -// Assumes IEEE-754 floating-point arithmetic. -// -//go:linkname Fsum py.fsum -func Fsum(seq *py.Object) *py.Object -// Gamma function at x. -// -//go:linkname Gamma py.gamma -func Gamma(x *py.Object) *py.Object -// Greatest Common Divisor. -// -//go:linkname Gcd py.gcd -func Gcd(__llgo_va_list ...interface{}) *py.Object -// Return x * (2**i). -// -// This is essentially the inverse of frexp(). -// -//go:linkname Ldexp py.ldexp -func Ldexp(x *py.Object, i *py.Object) *py.Object -// Natural logarithm of absolute value of Gamma function at x. -// -//go:linkname Lgamma py.lgamma -func Lgamma(x *py.Object) *py.Object -// Return the base 10 logarithm of x. -// -//go:linkname Log10 py.log10 -func Log10(x *py.Object) *py.Object -// Return the base 2 logarithm of x. -// -//go:linkname Log2 py.log2 -func Log2(x *py.Object) *py.Object -// Return the fractional and integer parts of x. -// -// Both results carry the sign of x and are floats. -// -//go:linkname Modf py.modf -func Modf(x *py.Object) *py.Object -// Return x**y (x to the power of y). -// -//go:linkname Pow py.pow -func Pow(x *py.Object, y *py.Object) *py.Object -// Convert angle x from degrees to radians. -// -//go:linkname Radians py.radians -func Radians(x *py.Object) *py.Object -// Difference between x and the closest integer multiple of y. -// -// Return x - n*y where n*y is the closest integer multiple of y. -// In the case where x is exactly halfway between two multiples of -// y, the nearest even value of n is used. The result is always exact. -// -//go:linkname Remainder py.remainder -func Remainder(x *py.Object, y *py.Object) *py.Object -// Return the sine of x (measured in radians). -// -//go:linkname Sin py.sin -func Sin(x *py.Object) *py.Object -// Return the hyperbolic sine of x. -// -//go:linkname Sinh py.sinh -func Sinh(x *py.Object) *py.Object -// Return the square root of x. -// -//go:linkname Sqrt py.sqrt -func Sqrt(x *py.Object) *py.Object -// Return the tangent of x (measured in radians). -// -//go:linkname Tan py.tan -func Tan(x *py.Object) *py.Object -// Return the hyperbolic tangent of x. -// -//go:linkname Tanh py.tanh -func Tanh(x *py.Object) *py.Object -// Return the sum of products of values from two iterables p and q. -// -// Roughly equivalent to: -// -// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) -// -// For float and mixed int/float inputs, the intermediate products -// and sums are computed with extended precision. -// -//go:linkname Sumprod py.sumprod -func Sumprod(p *py.Object, q *py.Object) *py.Object -// Truncates the Real x to the nearest Integral toward 0. -// -// Uses the __trunc__ magic method. -// -//go:linkname Trunc py.trunc -func Trunc(x *py.Object) *py.Object -// Calculate the product of all the elements in the input iterable. -// -// The default start value for the product is 1. -// -// When the iterable is empty, return the start value. This function is -// intended specifically for use with numeric values and may reject -// non-numeric types. -// -//go:linkname Prod py.prod -func Prod(iterable *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and with order. -// -// Evaluates to n! / (n - k)! when k <= n and evaluates -// to zero when k > n. -// -// If k is not specified or is None, then k defaults to n -// and the function returns n!. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Perm py.perm -func Perm(n *py.Object, k *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and without order. -// -// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates -// to zero when k > n. -// -// Also called the binomial coefficient because it is equivalent -// to the coefficient of k-th term in polynomial expansion of the -// expression (1 + x)**n. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Comb py.comb -func Comb(n *py.Object, k *py.Object) *py.Object -// Return the floating-point value the given number of steps after x towards y. -// -// If steps is not specified or is None, it defaults to 1. -// -// Raises a TypeError, if x or y is not a double, or if steps is not an integer. -// Raises ValueError if steps is negative. -// -//go:linkname Nextafter py.nextafter -func Nextafter(x *py.Object, y *py.Object) *py.Object -// Return the value of the least significant bit of the float x. -// -//go:linkname Ulp py.ulp -func Ulp(x *py.Object) *py.Object diff --git a/math/math_autogen_link.go b/math/math_autogen_link.go deleted file mode 100644 index 1f657e14..00000000 --- a/math/math_autogen_link.go +++ /dev/null @@ -1,5 +0,0 @@ -package math - -import _ "github.com/goplus/lib/py" - -// LLGoPackage is defined in the main binding file diff --git a/math4/_demo/go.mod b/math4/_demo/go.mod deleted file mode 100644 index 46f5f92f..00000000 --- a/math4/_demo/go.mod +++ /dev/null @@ -1,10 +0,0 @@ -module test_math3 - -go 1.24.5 - -replace github.com/goplus/llpkg/math => ../ - -require ( - github.com/goplus/lib v0.2.0 - github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 -) diff --git a/math4/_demo/go.sum b/math4/_demo/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/math4/_demo/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math4/_demo/main.go b/math4/_demo/main.go deleted file mode 100644 index 023355a1..00000000 --- a/math4/_demo/main.go +++ /dev/null @@ -1,29 +0,0 @@ -package main - -import ( - "github.com/goplus/lib/py" - "github.com/goplus/lib/py/std" - "github.com/goplus/llpkg/math" -) - -func main() { - // 初始化 Python - py.Initialize() - defer py.Finalize() - - // 测试 math.Sqrt - result1 := math.Sqrt(py.Float(4.0)) - std.Print(py.Str("sqrt(4) = "), result1) - - // 测试 math.Cos - result2 := math.Cos(py.Float(0.0)) - std.Print(py.Str("cos(0) = "), result2) - - // 测试 math.Pow - result3 := math.Pow(py.Float(2.0), py.Float(3.0)) - std.Print(py.Str("2^3 = "), result3) - - // 测试 math.Sin - result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 - std.Print(py.Str("sin(1.57) = "), result4) -} diff --git a/math4/go.mod b/math4/go.mod deleted file mode 100644 index 7d6e6402..00000000 --- a/math4/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/goplus/llpkg/math - -go 1.23 - -require github.com/goplus/lib v0.2.0 diff --git a/math4/llpkg.cfg b/math4/llpkg.cfg deleted file mode 100644 index dd565d41..00000000 --- a/math4/llpkg.cfg +++ /dev/null @@ -1,16 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "python_version": "3.12", - "index_url": "https://pypi.org/simple/" - } - }, - "package": { - "name": "math", - "version": "builtin" - } - } -} \ No newline at end of file diff --git a/math4/llpyg.cfg b/math4/llpyg.cfg deleted file mode 100644 index 94275e92..00000000 --- a/math4/llpyg.cfg +++ /dev/null @@ -1,123 +0,0 @@ -{ - "name": "math", - "module": "math", - "python": true, - "symMap": { - "abs": "Abs", - "acos": "Acos", - "acosh": "Acosh", - "all": "All", - "any": "Any", - "asin": "Asin", - "asinh": "Asinh", - "atan": "Atan", - "atan2": "Atan2", - "atanh": "Atanh", - "bin": "Bin", - "bool": "Bool", - "cbrt": "Cbrt", - "ceil": "Ceil", - "chr": "Chr", - "comb": "Comb", - "copysign": "Copysign", - "cos": "Cos", - "cosh": "Cosh", - "degrees": "Degrees", - "dict": "Dict", - "dir": "Dir", - "dist": "Dist", - "enumerate": "Enumerate", - "erf": "Erf", - "erfc": "Erfc", - "exp": "Exp", - "exp2": "Exp2", - "expm1": "Expm1", - "fabs": "Fabs", - "factorial": "Factorial", - "filter": "Filter", - "float": "Float", - "floor": "Floor", - "fmod": "Fmod", - "format": "Format", - "frexp": "Frexp", - "frozenset": "FrozenSet", - "fsum": "Fsum", - "gamma": "Gamma", - "gcd": "Gcd", - "getattr": "GetAttr", - "hasattr": "HasAttr", - "hash": "Hash", - "help": "Help", - "hex": "Hex", - "id": "ID", - "input": "Input", - "int": "Int", - "isinstance": "IsInstance", - "issubclass": "IsSubclass", - "iter": "Iter", - "len": "Len", - "list": "List", - "locals": "Locals", - "log10": "Log10", - "log2": "Log2", - "map": "Map", - "max": "Max", - "min": "Min", - "modf": "Modf", - "next": "Next", - "nextafter": "Nextafter", - "oct": "Oct", - "open": "Open", - "ord": "Ord", - "perm": "Perm", - "pow": "Pow", - "print": "Print", - "prod": "Prod", - "radians": "Radians", - "range": "Range", - "remainder": "Remainder", - "repr": "Repr", - "reversed": "Reversed", - "round": "Round", - "set": "Set", - "setattr": "SetAttr", - "sin": "Sin", - "sinh": "Sinh", - "sorted": "Sorted", - "sqrt": "Sqrt", - "str": "Str", - "sum": "Sum", - "sumprod": "Sumprod", - "tan": "Tan", - "tanh": "Tanh", - "trunc": "Trunc", - "tuple": "Tuple", - "type": "Type", - "ulp": "Ulp", - "vars": "Vars", - "zip": "Zip" - }, - "deps": [ - "py" - ], - "include": [ - "math" - ], - "exclude": [ - "__builtins__", - "__cached__", - "__doc__", - "__file__", - "__loader__", - "__name__", - "__package__", - "__spec__" - ], - "constants": { - "e": "E", - "inf": "Inf", - "nan": "NaN", - "pi": "Pi", - "tau": "Tau" - } -} \ No newline at end of file diff --git a/math4/math.go b/math4/math.go deleted file mode 100644 index e497df6e..00000000 --- a/math4/math.go +++ /dev/null @@ -1,280 +0,0 @@ -package math - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -const LLGoPackage = "py.math" -// Return the arc cosine (measured in radians) of x. -// -// The result is between 0 and pi. -// -//go:linkname Acos py.acos -func Acos(x *py.Object) *py.Object -// Return the inverse hyperbolic cosine of x. -// -//go:linkname Acosh py.acosh -func Acosh(x *py.Object) *py.Object -// Return the arc sine (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Asin py.asin -func Asin(x *py.Object) *py.Object -// Return the inverse hyperbolic sine of x. -// -//go:linkname Asinh py.asinh -func Asinh(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Atan py.atan -func Atan(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of y/x. -// -// Unlike atan(y/x), the signs of both x and y are considered. -// -//go:linkname Atan2 py.atan2 -func Atan2(y *py.Object, x *py.Object) *py.Object -// Return the inverse hyperbolic tangent of x. -// -//go:linkname Atanh py.atanh -func Atanh(x *py.Object) *py.Object -// Return the cube root of x. -// -//go:linkname Cbrt py.cbrt -func Cbrt(x *py.Object) *py.Object -// Return the ceiling of x as an Integral. -// -// This is the smallest integer >= x. -// -//go:linkname Ceil py.ceil -func Ceil(x *py.Object) *py.Object -// Return a float with the magnitude (absolute value) of x but the sign of y. -// -// On platforms that support signed zeros, copysign(1.0, -0.0) -// returns -1.0. -// -// -//go:linkname Copysign py.copysign -func Copysign(x *py.Object, y *py.Object) *py.Object -// Return the cosine of x (measured in radians). -// -//go:linkname Cos py.cos -func Cos(x *py.Object) *py.Object -// Return the hyperbolic cosine of x. -// -//go:linkname Cosh py.cosh -func Cosh(x *py.Object) *py.Object -// Convert angle x from radians to degrees. -// -//go:linkname Degrees py.degrees -func Degrees(x *py.Object) *py.Object -// Return the Euclidean distance between two points p and q. -// -// The points should be specified as sequences (or iterables) of -// coordinates. Both inputs must have the same dimension. -// -// Roughly equivalent to: -// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) -// -//go:linkname Dist py.dist -func Dist(p *py.Object, q *py.Object) *py.Object -// Error function at x. -// -//go:linkname Erf py.erf -func Erf(x *py.Object) *py.Object -// Complementary error function at x. -// -//go:linkname Erfc py.erfc -func Erfc(x *py.Object) *py.Object -// Return e raised to the power of x. -// -//go:linkname Exp py.exp -func Exp(x *py.Object) *py.Object -// Return 2 raised to the power of x. -// -//go:linkname Exp2 py.exp2 -func Exp2(x *py.Object) *py.Object -// Return exp(x)-1. -// -// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. -// -//go:linkname Expm1 py.expm1 -func Expm1(x *py.Object) *py.Object -// Return the absolute value of the float x. -// -//go:linkname Fabs py.fabs -func Fabs(x *py.Object) *py.Object -// Find n!. -// -// Raise a ValueError if x is negative or non-integral. -// -//go:linkname Factorial py.factorial -func Factorial(n *py.Object) *py.Object -// Return the floor of x as an Integral. -// -// This is the largest integer <= x. -// -//go:linkname Floor py.floor -func Floor(x *py.Object) *py.Object -// Return fmod(x, y), according to platform C. -// -// x % y may differ. -// -//go:linkname Fmod py.fmod -func Fmod(x *py.Object, y *py.Object) *py.Object -// Return the mantissa and exponent of x, as pair (m, e). -// -// m is a float and e is an int, such that x = m * 2.**e. -// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. -// -//go:linkname Frexp py.frexp -func Frexp(x *py.Object) *py.Object -// Return an accurate floating-point sum of values in the iterable seq. -// -// Assumes IEEE-754 floating-point arithmetic. -// -//go:linkname Fsum py.fsum -func Fsum(seq *py.Object) *py.Object -// Gamma function at x. -// -//go:linkname Gamma py.gamma -func Gamma(x *py.Object) *py.Object -// Greatest Common Divisor. -// -//go:linkname Gcd py.gcd -func Gcd(__llgo_va_list ...interface{}) *py.Object -// Return the integer part of the square root of the input. -// -//go:linkname Isqrt py.isqrt -func Isqrt(n *py.Object) *py.Object -// Least Common Multiple. -// -//go:linkname Lcm py.lcm -func Lcm(__llgo_va_list ...interface{}) *py.Object -// Return x * (2**i). -// -// This is essentially the inverse of frexp(). -// -//go:linkname Ldexp py.ldexp -func Ldexp(x *py.Object, i *py.Object) *py.Object -// Natural logarithm of absolute value of Gamma function at x. -// -//go:linkname Lgamma py.lgamma -func Lgamma(x *py.Object) *py.Object -// Return the base 2 logarithm of x. -// -//go:linkname Log2 py.log2 -func Log2(x *py.Object) *py.Object -// Return the fractional and integer parts of x. -// -// Both results carry the sign of x and are floats. -// -//go:linkname Modf py.modf -func Modf(x *py.Object) *py.Object -// Return x**y (x to the power of y). -// -//go:linkname Pow py.pow -func Pow(x *py.Object, y *py.Object) *py.Object -// Convert angle x from degrees to radians. -// -//go:linkname Radians py.radians -func Radians(x *py.Object) *py.Object -// Difference between x and the closest integer multiple of y. -// -// Return x - n*y where n*y is the closest integer multiple of y. -// In the case where x is exactly halfway between two multiples of -// y, the nearest even value of n is used. The result is always exact. -// -//go:linkname Remainder py.remainder -func Remainder(x *py.Object, y *py.Object) *py.Object -// Return the sine of x (measured in radians). -// -//go:linkname Sin py.sin -func Sin(x *py.Object) *py.Object -// Return the hyperbolic sine of x. -// -//go:linkname Sinh py.sinh -func Sinh(x *py.Object) *py.Object -// Return the square root of x. -// -//go:linkname Sqrt py.sqrt -func Sqrt(x *py.Object) *py.Object -// Return the tangent of x (measured in radians). -// -//go:linkname Tan py.tan -func Tan(x *py.Object) *py.Object -// Return the hyperbolic tangent of x. -// -//go:linkname Tanh py.tanh -func Tanh(x *py.Object) *py.Object -// Return the sum of products of values from two iterables p and q. -// -// Roughly equivalent to: -// -// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) -// -// For float and mixed int/float inputs, the intermediate products -// and sums are computed with extended precision. -// -//go:linkname Sumprod py.sumprod -func Sumprod(p *py.Object, q *py.Object) *py.Object -// Truncates the Real x to the nearest Integral toward 0. -// -// Uses the __trunc__ magic method. -// -//go:linkname Trunc py.trunc -func Trunc(x *py.Object) *py.Object -// Calculate the product of all the elements in the input iterable. -// -// The default start value for the product is 1. -// -// When the iterable is empty, return the start value. This function is -// intended specifically for use with numeric values and may reject -// non-numeric types. -// -//go:linkname Prod py.prod -func Prod(iterable *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and with order. -// -// Evaluates to n! / (n - k)! when k <= n and evaluates -// to zero when k > n. -// -// If k is not specified or is None, then k defaults to n -// and the function returns n!. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Perm py.perm -func Perm(n *py.Object, k *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and without order. -// -// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates -// to zero when k > n. -// -// Also called the binomial coefficient because it is equivalent -// to the coefficient of k-th term in polynomial expansion of the -// expression (1 + x)**n. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Comb py.comb -func Comb(n *py.Object, k *py.Object) *py.Object -// Return the floating-point value the given number of steps after x towards y. -// -// If steps is not specified or is None, it defaults to 1. -// -// Raises a TypeError, if x or y is not a double, or if steps is not an integer. -// Raises ValueError if steps is negative. -// -//go:linkname Nextafter py.nextafter -func Nextafter(x *py.Object, y *py.Object) *py.Object -// Return the value of the least significant bit of the float x. -// -//go:linkname Ulp py.ulp -func Ulp(x *py.Object) *py.Object diff --git a/math4/math_autogen_link.go b/math4/math_autogen_link.go deleted file mode 100644 index 1f657e14..00000000 --- a/math4/math_autogen_link.go +++ /dev/null @@ -1,5 +0,0 @@ -package math - -import _ "github.com/goplus/lib/py" - -// LLGoPackage is defined in the main binding file diff --git a/math5/_demo/go.mod b/math5/_demo/go.mod deleted file mode 100644 index 46f5f92f..00000000 --- a/math5/_demo/go.mod +++ /dev/null @@ -1,10 +0,0 @@ -module test_math3 - -go 1.24.5 - -replace github.com/goplus/llpkg/math => ../ - -require ( - github.com/goplus/lib v0.2.0 - github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 -) diff --git a/math5/_demo/go.sum b/math5/_demo/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/math5/_demo/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math5/_demo/main.go b/math5/_demo/main.go deleted file mode 100644 index 023355a1..00000000 --- a/math5/_demo/main.go +++ /dev/null @@ -1,29 +0,0 @@ -package main - -import ( - "github.com/goplus/lib/py" - "github.com/goplus/lib/py/std" - "github.com/goplus/llpkg/math" -) - -func main() { - // 初始化 Python - py.Initialize() - defer py.Finalize() - - // 测试 math.Sqrt - result1 := math.Sqrt(py.Float(4.0)) - std.Print(py.Str("sqrt(4) = "), result1) - - // 测试 math.Cos - result2 := math.Cos(py.Float(0.0)) - std.Print(py.Str("cos(0) = "), result2) - - // 测试 math.Pow - result3 := math.Pow(py.Float(2.0), py.Float(3.0)) - std.Print(py.Str("2^3 = "), result3) - - // 测试 math.Sin - result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 - std.Print(py.Str("sin(1.57) = "), result4) -} diff --git a/math5/go.mod b/math5/go.mod deleted file mode 100644 index 7d6e6402..00000000 --- a/math5/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/goplus/llpkg/math - -go 1.23 - -require github.com/goplus/lib v0.2.0 diff --git a/math5/llpkg.cfg b/math5/llpkg.cfg deleted file mode 100644 index dd565d41..00000000 --- a/math5/llpkg.cfg +++ /dev/null @@ -1,16 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "python_version": "3.12", - "index_url": "https://pypi.org/simple/" - } - }, - "package": { - "name": "math", - "version": "builtin" - } - } -} \ No newline at end of file diff --git a/math5/llpyg.cfg b/math5/llpyg.cfg deleted file mode 100644 index 94275e92..00000000 --- a/math5/llpyg.cfg +++ /dev/null @@ -1,123 +0,0 @@ -{ - "name": "math", - "module": "math", - "python": true, - "symMap": { - "abs": "Abs", - "acos": "Acos", - "acosh": "Acosh", - "all": "All", - "any": "Any", - "asin": "Asin", - "asinh": "Asinh", - "atan": "Atan", - "atan2": "Atan2", - "atanh": "Atanh", - "bin": "Bin", - "bool": "Bool", - "cbrt": "Cbrt", - "ceil": "Ceil", - "chr": "Chr", - "comb": "Comb", - "copysign": "Copysign", - "cos": "Cos", - "cosh": "Cosh", - "degrees": "Degrees", - "dict": "Dict", - "dir": "Dir", - "dist": "Dist", - "enumerate": "Enumerate", - "erf": "Erf", - "erfc": "Erfc", - "exp": "Exp", - "exp2": "Exp2", - "expm1": "Expm1", - "fabs": "Fabs", - "factorial": "Factorial", - "filter": "Filter", - "float": "Float", - "floor": "Floor", - "fmod": "Fmod", - "format": "Format", - "frexp": "Frexp", - "frozenset": "FrozenSet", - "fsum": "Fsum", - "gamma": "Gamma", - "gcd": "Gcd", - "getattr": "GetAttr", - "hasattr": "HasAttr", - "hash": "Hash", - "help": "Help", - "hex": "Hex", - "id": "ID", - "input": "Input", - "int": "Int", - "isinstance": "IsInstance", - "issubclass": "IsSubclass", - "iter": "Iter", - "len": "Len", - "list": "List", - "locals": "Locals", - "log10": "Log10", - "log2": "Log2", - "map": "Map", - "max": "Max", - "min": "Min", - "modf": "Modf", - "next": "Next", - "nextafter": "Nextafter", - "oct": "Oct", - "open": "Open", - "ord": "Ord", - "perm": "Perm", - "pow": "Pow", - "print": "Print", - "prod": "Prod", - "radians": "Radians", - "range": "Range", - "remainder": "Remainder", - "repr": "Repr", - "reversed": "Reversed", - "round": "Round", - "set": "Set", - "setattr": "SetAttr", - "sin": "Sin", - "sinh": "Sinh", - "sorted": "Sorted", - "sqrt": "Sqrt", - "str": "Str", - "sum": "Sum", - "sumprod": "Sumprod", - "tan": "Tan", - "tanh": "Tanh", - "trunc": "Trunc", - "tuple": "Tuple", - "type": "Type", - "ulp": "Ulp", - "vars": "Vars", - "zip": "Zip" - }, - "deps": [ - "py" - ], - "include": [ - "math" - ], - "exclude": [ - "__builtins__", - "__cached__", - "__doc__", - "__file__", - "__loader__", - "__name__", - "__package__", - "__spec__" - ], - "constants": { - "e": "E", - "inf": "Inf", - "nan": "NaN", - "pi": "Pi", - "tau": "Tau" - } -} \ No newline at end of file diff --git a/math5/math.go b/math5/math.go deleted file mode 100644 index e497df6e..00000000 --- a/math5/math.go +++ /dev/null @@ -1,280 +0,0 @@ -package math - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -const LLGoPackage = "py.math" -// Return the arc cosine (measured in radians) of x. -// -// The result is between 0 and pi. -// -//go:linkname Acos py.acos -func Acos(x *py.Object) *py.Object -// Return the inverse hyperbolic cosine of x. -// -//go:linkname Acosh py.acosh -func Acosh(x *py.Object) *py.Object -// Return the arc sine (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Asin py.asin -func Asin(x *py.Object) *py.Object -// Return the inverse hyperbolic sine of x. -// -//go:linkname Asinh py.asinh -func Asinh(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Atan py.atan -func Atan(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of y/x. -// -// Unlike atan(y/x), the signs of both x and y are considered. -// -//go:linkname Atan2 py.atan2 -func Atan2(y *py.Object, x *py.Object) *py.Object -// Return the inverse hyperbolic tangent of x. -// -//go:linkname Atanh py.atanh -func Atanh(x *py.Object) *py.Object -// Return the cube root of x. -// -//go:linkname Cbrt py.cbrt -func Cbrt(x *py.Object) *py.Object -// Return the ceiling of x as an Integral. -// -// This is the smallest integer >= x. -// -//go:linkname Ceil py.ceil -func Ceil(x *py.Object) *py.Object -// Return a float with the magnitude (absolute value) of x but the sign of y. -// -// On platforms that support signed zeros, copysign(1.0, -0.0) -// returns -1.0. -// -// -//go:linkname Copysign py.copysign -func Copysign(x *py.Object, y *py.Object) *py.Object -// Return the cosine of x (measured in radians). -// -//go:linkname Cos py.cos -func Cos(x *py.Object) *py.Object -// Return the hyperbolic cosine of x. -// -//go:linkname Cosh py.cosh -func Cosh(x *py.Object) *py.Object -// Convert angle x from radians to degrees. -// -//go:linkname Degrees py.degrees -func Degrees(x *py.Object) *py.Object -// Return the Euclidean distance between two points p and q. -// -// The points should be specified as sequences (or iterables) of -// coordinates. Both inputs must have the same dimension. -// -// Roughly equivalent to: -// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) -// -//go:linkname Dist py.dist -func Dist(p *py.Object, q *py.Object) *py.Object -// Error function at x. -// -//go:linkname Erf py.erf -func Erf(x *py.Object) *py.Object -// Complementary error function at x. -// -//go:linkname Erfc py.erfc -func Erfc(x *py.Object) *py.Object -// Return e raised to the power of x. -// -//go:linkname Exp py.exp -func Exp(x *py.Object) *py.Object -// Return 2 raised to the power of x. -// -//go:linkname Exp2 py.exp2 -func Exp2(x *py.Object) *py.Object -// Return exp(x)-1. -// -// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. -// -//go:linkname Expm1 py.expm1 -func Expm1(x *py.Object) *py.Object -// Return the absolute value of the float x. -// -//go:linkname Fabs py.fabs -func Fabs(x *py.Object) *py.Object -// Find n!. -// -// Raise a ValueError if x is negative or non-integral. -// -//go:linkname Factorial py.factorial -func Factorial(n *py.Object) *py.Object -// Return the floor of x as an Integral. -// -// This is the largest integer <= x. -// -//go:linkname Floor py.floor -func Floor(x *py.Object) *py.Object -// Return fmod(x, y), according to platform C. -// -// x % y may differ. -// -//go:linkname Fmod py.fmod -func Fmod(x *py.Object, y *py.Object) *py.Object -// Return the mantissa and exponent of x, as pair (m, e). -// -// m is a float and e is an int, such that x = m * 2.**e. -// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. -// -//go:linkname Frexp py.frexp -func Frexp(x *py.Object) *py.Object -// Return an accurate floating-point sum of values in the iterable seq. -// -// Assumes IEEE-754 floating-point arithmetic. -// -//go:linkname Fsum py.fsum -func Fsum(seq *py.Object) *py.Object -// Gamma function at x. -// -//go:linkname Gamma py.gamma -func Gamma(x *py.Object) *py.Object -// Greatest Common Divisor. -// -//go:linkname Gcd py.gcd -func Gcd(__llgo_va_list ...interface{}) *py.Object -// Return the integer part of the square root of the input. -// -//go:linkname Isqrt py.isqrt -func Isqrt(n *py.Object) *py.Object -// Least Common Multiple. -// -//go:linkname Lcm py.lcm -func Lcm(__llgo_va_list ...interface{}) *py.Object -// Return x * (2**i). -// -// This is essentially the inverse of frexp(). -// -//go:linkname Ldexp py.ldexp -func Ldexp(x *py.Object, i *py.Object) *py.Object -// Natural logarithm of absolute value of Gamma function at x. -// -//go:linkname Lgamma py.lgamma -func Lgamma(x *py.Object) *py.Object -// Return the base 2 logarithm of x. -// -//go:linkname Log2 py.log2 -func Log2(x *py.Object) *py.Object -// Return the fractional and integer parts of x. -// -// Both results carry the sign of x and are floats. -// -//go:linkname Modf py.modf -func Modf(x *py.Object) *py.Object -// Return x**y (x to the power of y). -// -//go:linkname Pow py.pow -func Pow(x *py.Object, y *py.Object) *py.Object -// Convert angle x from degrees to radians. -// -//go:linkname Radians py.radians -func Radians(x *py.Object) *py.Object -// Difference between x and the closest integer multiple of y. -// -// Return x - n*y where n*y is the closest integer multiple of y. -// In the case where x is exactly halfway between two multiples of -// y, the nearest even value of n is used. The result is always exact. -// -//go:linkname Remainder py.remainder -func Remainder(x *py.Object, y *py.Object) *py.Object -// Return the sine of x (measured in radians). -// -//go:linkname Sin py.sin -func Sin(x *py.Object) *py.Object -// Return the hyperbolic sine of x. -// -//go:linkname Sinh py.sinh -func Sinh(x *py.Object) *py.Object -// Return the square root of x. -// -//go:linkname Sqrt py.sqrt -func Sqrt(x *py.Object) *py.Object -// Return the tangent of x (measured in radians). -// -//go:linkname Tan py.tan -func Tan(x *py.Object) *py.Object -// Return the hyperbolic tangent of x. -// -//go:linkname Tanh py.tanh -func Tanh(x *py.Object) *py.Object -// Return the sum of products of values from two iterables p and q. -// -// Roughly equivalent to: -// -// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) -// -// For float and mixed int/float inputs, the intermediate products -// and sums are computed with extended precision. -// -//go:linkname Sumprod py.sumprod -func Sumprod(p *py.Object, q *py.Object) *py.Object -// Truncates the Real x to the nearest Integral toward 0. -// -// Uses the __trunc__ magic method. -// -//go:linkname Trunc py.trunc -func Trunc(x *py.Object) *py.Object -// Calculate the product of all the elements in the input iterable. -// -// The default start value for the product is 1. -// -// When the iterable is empty, return the start value. This function is -// intended specifically for use with numeric values and may reject -// non-numeric types. -// -//go:linkname Prod py.prod -func Prod(iterable *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and with order. -// -// Evaluates to n! / (n - k)! when k <= n and evaluates -// to zero when k > n. -// -// If k is not specified or is None, then k defaults to n -// and the function returns n!. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Perm py.perm -func Perm(n *py.Object, k *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and without order. -// -// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates -// to zero when k > n. -// -// Also called the binomial coefficient because it is equivalent -// to the coefficient of k-th term in polynomial expansion of the -// expression (1 + x)**n. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Comb py.comb -func Comb(n *py.Object, k *py.Object) *py.Object -// Return the floating-point value the given number of steps after x towards y. -// -// If steps is not specified or is None, it defaults to 1. -// -// Raises a TypeError, if x or y is not a double, or if steps is not an integer. -// Raises ValueError if steps is negative. -// -//go:linkname Nextafter py.nextafter -func Nextafter(x *py.Object, y *py.Object) *py.Object -// Return the value of the least significant bit of the float x. -// -//go:linkname Ulp py.ulp -func Ulp(x *py.Object) *py.Object diff --git a/math5/math_autogen_link.go b/math5/math_autogen_link.go deleted file mode 100644 index 1f657e14..00000000 --- a/math5/math_autogen_link.go +++ /dev/null @@ -1,5 +0,0 @@ -package math - -import _ "github.com/goplus/lib/py" - -// LLGoPackage is defined in the main binding file diff --git a/math6/_demo/go.mod b/math6/_demo/go.mod deleted file mode 100644 index 46f5f92f..00000000 --- a/math6/_demo/go.mod +++ /dev/null @@ -1,10 +0,0 @@ -module test_math3 - -go 1.24.5 - -replace github.com/goplus/llpkg/math => ../ - -require ( - github.com/goplus/lib v0.2.0 - github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 -) diff --git a/math6/_demo/go.sum b/math6/_demo/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/math6/_demo/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/math6/_demo/main.go b/math6/_demo/main.go deleted file mode 100644 index 023355a1..00000000 --- a/math6/_demo/main.go +++ /dev/null @@ -1,29 +0,0 @@ -package main - -import ( - "github.com/goplus/lib/py" - "github.com/goplus/lib/py/std" - "github.com/goplus/llpkg/math" -) - -func main() { - // 初始化 Python - py.Initialize() - defer py.Finalize() - - // 测试 math.Sqrt - result1 := math.Sqrt(py.Float(4.0)) - std.Print(py.Str("sqrt(4) = "), result1) - - // 测试 math.Cos - result2 := math.Cos(py.Float(0.0)) - std.Print(py.Str("cos(0) = "), result2) - - // 测试 math.Pow - result3 := math.Pow(py.Float(2.0), py.Float(3.0)) - std.Print(py.Str("2^3 = "), result3) - - // 测试 math.Sin - result4 := math.Sin(py.Float(1.57)) // 接近 pi/2 - std.Print(py.Str("sin(1.57) = "), result4) -} diff --git a/math6/go.mod b/math6/go.mod deleted file mode 100644 index 7d6e6402..00000000 --- a/math6/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/goplus/llpkg/math - -go 1.23 - -require github.com/goplus/lib v0.2.0 diff --git a/math6/llpkg.cfg b/math6/llpkg.cfg deleted file mode 100644 index dd565d41..00000000 --- a/math6/llpkg.cfg +++ /dev/null @@ -1,16 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "python_version": "3.12", - "index_url": "https://pypi.org/simple/" - } - }, - "package": { - "name": "math", - "version": "builtin" - } - } -} \ No newline at end of file diff --git a/math6/llpyg.cfg b/math6/llpyg.cfg deleted file mode 100644 index 94275e92..00000000 --- a/math6/llpyg.cfg +++ /dev/null @@ -1,123 +0,0 @@ -{ - "name": "math", - "module": "math", - "python": true, - "symMap": { - "abs": "Abs", - "acos": "Acos", - "acosh": "Acosh", - "all": "All", - "any": "Any", - "asin": "Asin", - "asinh": "Asinh", - "atan": "Atan", - "atan2": "Atan2", - "atanh": "Atanh", - "bin": "Bin", - "bool": "Bool", - "cbrt": "Cbrt", - "ceil": "Ceil", - "chr": "Chr", - "comb": "Comb", - "copysign": "Copysign", - "cos": "Cos", - "cosh": "Cosh", - "degrees": "Degrees", - "dict": "Dict", - "dir": "Dir", - "dist": "Dist", - "enumerate": "Enumerate", - "erf": "Erf", - "erfc": "Erfc", - "exp": "Exp", - "exp2": "Exp2", - "expm1": "Expm1", - "fabs": "Fabs", - "factorial": "Factorial", - "filter": "Filter", - "float": "Float", - "floor": "Floor", - "fmod": "Fmod", - "format": "Format", - "frexp": "Frexp", - "frozenset": "FrozenSet", - "fsum": "Fsum", - "gamma": "Gamma", - "gcd": "Gcd", - "getattr": "GetAttr", - "hasattr": "HasAttr", - "hash": "Hash", - "help": "Help", - "hex": "Hex", - "id": "ID", - "input": "Input", - "int": "Int", - "isinstance": "IsInstance", - "issubclass": "IsSubclass", - "iter": "Iter", - "len": "Len", - "list": "List", - "locals": "Locals", - "log10": "Log10", - "log2": "Log2", - "map": "Map", - "max": "Max", - "min": "Min", - "modf": "Modf", - "next": "Next", - "nextafter": "Nextafter", - "oct": "Oct", - "open": "Open", - "ord": "Ord", - "perm": "Perm", - "pow": "Pow", - "print": "Print", - "prod": "Prod", - "radians": "Radians", - "range": "Range", - "remainder": "Remainder", - "repr": "Repr", - "reversed": "Reversed", - "round": "Round", - "set": "Set", - "setattr": "SetAttr", - "sin": "Sin", - "sinh": "Sinh", - "sorted": "Sorted", - "sqrt": "Sqrt", - "str": "Str", - "sum": "Sum", - "sumprod": "Sumprod", - "tan": "Tan", - "tanh": "Tanh", - "trunc": "Trunc", - "tuple": "Tuple", - "type": "Type", - "ulp": "Ulp", - "vars": "Vars", - "zip": "Zip" - }, - "deps": [ - "py" - ], - "include": [ - "math" - ], - "exclude": [ - "__builtins__", - "__cached__", - "__doc__", - "__file__", - "__loader__", - "__name__", - "__package__", - "__spec__" - ], - "constants": { - "e": "E", - "inf": "Inf", - "nan": "NaN", - "pi": "Pi", - "tau": "Tau" - } -} \ No newline at end of file diff --git a/math6/math.go b/math6/math.go deleted file mode 100644 index e497df6e..00000000 --- a/math6/math.go +++ /dev/null @@ -1,280 +0,0 @@ -package math - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -const LLGoPackage = "py.math" -// Return the arc cosine (measured in radians) of x. -// -// The result is between 0 and pi. -// -//go:linkname Acos py.acos -func Acos(x *py.Object) *py.Object -// Return the inverse hyperbolic cosine of x. -// -//go:linkname Acosh py.acosh -func Acosh(x *py.Object) *py.Object -// Return the arc sine (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Asin py.asin -func Asin(x *py.Object) *py.Object -// Return the inverse hyperbolic sine of x. -// -//go:linkname Asinh py.asinh -func Asinh(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of x. -// -// The result is between -pi/2 and pi/2. -// -//go:linkname Atan py.atan -func Atan(x *py.Object) *py.Object -// Return the arc tangent (measured in radians) of y/x. -// -// Unlike atan(y/x), the signs of both x and y are considered. -// -//go:linkname Atan2 py.atan2 -func Atan2(y *py.Object, x *py.Object) *py.Object -// Return the inverse hyperbolic tangent of x. -// -//go:linkname Atanh py.atanh -func Atanh(x *py.Object) *py.Object -// Return the cube root of x. -// -//go:linkname Cbrt py.cbrt -func Cbrt(x *py.Object) *py.Object -// Return the ceiling of x as an Integral. -// -// This is the smallest integer >= x. -// -//go:linkname Ceil py.ceil -func Ceil(x *py.Object) *py.Object -// Return a float with the magnitude (absolute value) of x but the sign of y. -// -// On platforms that support signed zeros, copysign(1.0, -0.0) -// returns -1.0. -// -// -//go:linkname Copysign py.copysign -func Copysign(x *py.Object, y *py.Object) *py.Object -// Return the cosine of x (measured in radians). -// -//go:linkname Cos py.cos -func Cos(x *py.Object) *py.Object -// Return the hyperbolic cosine of x. -// -//go:linkname Cosh py.cosh -func Cosh(x *py.Object) *py.Object -// Convert angle x from radians to degrees. -// -//go:linkname Degrees py.degrees -func Degrees(x *py.Object) *py.Object -// Return the Euclidean distance between two points p and q. -// -// The points should be specified as sequences (or iterables) of -// coordinates. Both inputs must have the same dimension. -// -// Roughly equivalent to: -// sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) -// -//go:linkname Dist py.dist -func Dist(p *py.Object, q *py.Object) *py.Object -// Error function at x. -// -//go:linkname Erf py.erf -func Erf(x *py.Object) *py.Object -// Complementary error function at x. -// -//go:linkname Erfc py.erfc -func Erfc(x *py.Object) *py.Object -// Return e raised to the power of x. -// -//go:linkname Exp py.exp -func Exp(x *py.Object) *py.Object -// Return 2 raised to the power of x. -// -//go:linkname Exp2 py.exp2 -func Exp2(x *py.Object) *py.Object -// Return exp(x)-1. -// -// This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. -// -//go:linkname Expm1 py.expm1 -func Expm1(x *py.Object) *py.Object -// Return the absolute value of the float x. -// -//go:linkname Fabs py.fabs -func Fabs(x *py.Object) *py.Object -// Find n!. -// -// Raise a ValueError if x is negative or non-integral. -// -//go:linkname Factorial py.factorial -func Factorial(n *py.Object) *py.Object -// Return the floor of x as an Integral. -// -// This is the largest integer <= x. -// -//go:linkname Floor py.floor -func Floor(x *py.Object) *py.Object -// Return fmod(x, y), according to platform C. -// -// x % y may differ. -// -//go:linkname Fmod py.fmod -func Fmod(x *py.Object, y *py.Object) *py.Object -// Return the mantissa and exponent of x, as pair (m, e). -// -// m is a float and e is an int, such that x = m * 2.**e. -// If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. -// -//go:linkname Frexp py.frexp -func Frexp(x *py.Object) *py.Object -// Return an accurate floating-point sum of values in the iterable seq. -// -// Assumes IEEE-754 floating-point arithmetic. -// -//go:linkname Fsum py.fsum -func Fsum(seq *py.Object) *py.Object -// Gamma function at x. -// -//go:linkname Gamma py.gamma -func Gamma(x *py.Object) *py.Object -// Greatest Common Divisor. -// -//go:linkname Gcd py.gcd -func Gcd(__llgo_va_list ...interface{}) *py.Object -// Return the integer part of the square root of the input. -// -//go:linkname Isqrt py.isqrt -func Isqrt(n *py.Object) *py.Object -// Least Common Multiple. -// -//go:linkname Lcm py.lcm -func Lcm(__llgo_va_list ...interface{}) *py.Object -// Return x * (2**i). -// -// This is essentially the inverse of frexp(). -// -//go:linkname Ldexp py.ldexp -func Ldexp(x *py.Object, i *py.Object) *py.Object -// Natural logarithm of absolute value of Gamma function at x. -// -//go:linkname Lgamma py.lgamma -func Lgamma(x *py.Object) *py.Object -// Return the base 2 logarithm of x. -// -//go:linkname Log2 py.log2 -func Log2(x *py.Object) *py.Object -// Return the fractional and integer parts of x. -// -// Both results carry the sign of x and are floats. -// -//go:linkname Modf py.modf -func Modf(x *py.Object) *py.Object -// Return x**y (x to the power of y). -// -//go:linkname Pow py.pow -func Pow(x *py.Object, y *py.Object) *py.Object -// Convert angle x from degrees to radians. -// -//go:linkname Radians py.radians -func Radians(x *py.Object) *py.Object -// Difference between x and the closest integer multiple of y. -// -// Return x - n*y where n*y is the closest integer multiple of y. -// In the case where x is exactly halfway between two multiples of -// y, the nearest even value of n is used. The result is always exact. -// -//go:linkname Remainder py.remainder -func Remainder(x *py.Object, y *py.Object) *py.Object -// Return the sine of x (measured in radians). -// -//go:linkname Sin py.sin -func Sin(x *py.Object) *py.Object -// Return the hyperbolic sine of x. -// -//go:linkname Sinh py.sinh -func Sinh(x *py.Object) *py.Object -// Return the square root of x. -// -//go:linkname Sqrt py.sqrt -func Sqrt(x *py.Object) *py.Object -// Return the tangent of x (measured in radians). -// -//go:linkname Tan py.tan -func Tan(x *py.Object) *py.Object -// Return the hyperbolic tangent of x. -// -//go:linkname Tanh py.tanh -func Tanh(x *py.Object) *py.Object -// Return the sum of products of values from two iterables p and q. -// -// Roughly equivalent to: -// -// sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) -// -// For float and mixed int/float inputs, the intermediate products -// and sums are computed with extended precision. -// -//go:linkname Sumprod py.sumprod -func Sumprod(p *py.Object, q *py.Object) *py.Object -// Truncates the Real x to the nearest Integral toward 0. -// -// Uses the __trunc__ magic method. -// -//go:linkname Trunc py.trunc -func Trunc(x *py.Object) *py.Object -// Calculate the product of all the elements in the input iterable. -// -// The default start value for the product is 1. -// -// When the iterable is empty, return the start value. This function is -// intended specifically for use with numeric values and may reject -// non-numeric types. -// -//go:linkname Prod py.prod -func Prod(iterable *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and with order. -// -// Evaluates to n! / (n - k)! when k <= n and evaluates -// to zero when k > n. -// -// If k is not specified or is None, then k defaults to n -// and the function returns n!. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Perm py.perm -func Perm(n *py.Object, k *py.Object) *py.Object -// Number of ways to choose k items from n items without repetition and without order. -// -// Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates -// to zero when k > n. -// -// Also called the binomial coefficient because it is equivalent -// to the coefficient of k-th term in polynomial expansion of the -// expression (1 + x)**n. -// -// Raises TypeError if either of the arguments are not integers. -// Raises ValueError if either of the arguments are negative. -// -//go:linkname Comb py.comb -func Comb(n *py.Object, k *py.Object) *py.Object -// Return the floating-point value the given number of steps after x towards y. -// -// If steps is not specified or is None, it defaults to 1. -// -// Raises a TypeError, if x or y is not a double, or if steps is not an integer. -// Raises ValueError if steps is negative. -// -//go:linkname Nextafter py.nextafter -func Nextafter(x *py.Object, y *py.Object) *py.Object -// Return the value of the least significant bit of the float x. -// -//go:linkname Ulp py.ulp -func Ulp(x *py.Object) *py.Object diff --git a/math6/math_autogen_link.go b/math6/math_autogen_link.go deleted file mode 100644 index 1f657e14..00000000 --- a/math6/math_autogen_link.go +++ /dev/null @@ -1,5 +0,0 @@ -package math - -import _ "github.com/goplus/lib/py" - -// LLGoPackage is defined in the main binding file diff --git a/numpy/_demo/go.mod b/numpy/_demo/go.mod deleted file mode 100644 index 46f5f92f..00000000 --- a/numpy/_demo/go.mod +++ /dev/null @@ -1,10 +0,0 @@ -module test_math3 - -go 1.24.5 - -replace github.com/goplus/llpkg/math => ../ - -require ( - github.com/goplus/lib v0.2.0 - github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 -) diff --git a/numpy/_demo/go.sum b/numpy/_demo/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/numpy/_demo/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy/_demo/main.go b/numpy/_demo/main.go deleted file mode 100644 index c34d0173..00000000 --- a/numpy/_demo/main.go +++ /dev/null @@ -1,11 +0,0 @@ -package main - -import ( - "github.com/goplus/lib/py" -) - -func main() { - // 初始化 Python - py.Initialize() - defer py.Finalize() -} diff --git a/numpy/go.mod b/numpy/go.mod deleted file mode 100644 index 82bc5445..00000000 --- a/numpy/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/goplus/llpkg/numpy - -go 1.23 - -require github.com/goplus/lib v0.2.0 diff --git a/numpy/go.sum b/numpy/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/numpy/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy/llpkg.cfg b/numpy/llpkg.cfg deleted file mode 100644 index 44e6cd3e..00000000 --- a/numpy/llpkg.cfg +++ /dev/null @@ -1,16 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "python_version": "3.12", - "index_url": "https://pypi.org/simple/" - } - }, - "package": { - "name": "numpy", - "version": "1.26.4" - } - } -} \ No newline at end of file diff --git a/numpy/llpyg.cfg b/numpy/llpyg.cfg deleted file mode 100644 index b8888a8d..00000000 --- a/numpy/llpyg.cfg +++ /dev/null @@ -1,155 +0,0 @@ -{ - "name": "numpy", - "module": "numpy", - "python": true, - "symMap": { - "abs": "Abs", - "absolute": "Absolute", - "add": "Add", - "all": "All", - "any": "Any", - "arange": "Arange", - "arccos": "Arccos", - "arccosh": "Arccosh", - "arcsin": "Arcsin", - "arcsinh": "Arcsinh", - "arctan": "Arctan", - "arctanh": "Arctanh", - "array": "Array", - "average": "Average", - "bin": "Bin", - "bool": "Bool", - "c_": "C", - "ceil": "Ceil", - "chr": "Chr", - "corrcoef": "Corrcoef", - "cos": "Cos", - "cosh": "Cosh", - "cov": "Cov", - "cross": "Cross", - "diag": "Diag", - "dict": "Dict", - "dir": "Dir", - "divide": "Divide", - "dot": "Dot", - "einsum": "Einsum", - "empty": "Empty", - "enumerate": "Enumerate", - "exp": "Exp", - "eye": "Eye", - "fabs": "Fabs", - "fft": "Fft", - "filter": "Filter", - "float": "Float", - "floor": "Floor", - "format": "Format", - "frozenset": "FrozenSet", - "getattr": "GetAttr", - "hasattr": "HasAttr", - "hash": "Hash", - "help": "Help", - "hex": "Hex", - "id": "ID", - "identity": "Identity", - "inner": "Inner", - "input": "Input", - "int": "Int", - "isinstance": "IsInstance", - "issubclass": "IsSubclass", - "iter": "Iter", - "len": "Len", - "linalg": "Linalg", - "linspace": "Linspace", - "list": "List", - "locals": "Locals", - "log": "Log", - "log10": "Log10", - "log2": "Log2", - "logspace": "Logspace", - "map": "Map", - "matmul": "Matmul", - "max": "Max", - "mean": "Mean", - "median": "Median", - "meshgrid": "Meshgrid", - "mgrid": "Mgrid", - "min": "Min", - "mod": "Mod", - "multiply": "Multiply", - "next": "Next", - "oct": "Oct", - "ogrid": "Ogrid", - "ones": "Ones", - "open": "Open", - "ord": "Ord", - "outer": "Outer", - "percentile": "Percentile", - "pow": "Pow", - "power": "Power", - "print": "Print", - "prod": "Prod", - "ptp": "Ptp", - "quantile": "Quantile", - "r_": "R", - "random": "Random", - "range": "Range", - "remainder": "Remainder", - "repr": "Repr", - "reversed": "Reversed", - "rint": "Rint", - "round": "Round", - "set": "Set", - "setattr": "SetAttr", - "sign": "Sign", - "sin": "Sin", - "sinh": "Sinh", - "sorted": "Sorted", - "sqrt": "Sqrt", - "std": "Std", - "str": "Str", - "subtract": "Subtract", - "sum": "Sum", - "tan": "Tan", - "tanh": "Tanh", - "tensordot": "Tensordot", - "tri": "Tri", - "tril": "Tril", - "triu": "Triu", - "trunc": "Trunc", - "tuple": "Tuple", - "type": "Type", - "vander": "Vander", - "var": "Var", - "vars": "Vars", - "zeros": "Zeros", - "zip": "Zip" - }, - "deps": [ - "py" - ], - "include": [ - "numpy" - ], - "exclude": [ - "__builtins__", - "__cached__", - "__doc__", - "__file__", - "__loader__", - "__name__", - "__package__", - "__spec__" - ], - "constants": { - "bool_": "Bool", - "e": "E", - "float32": "Float32", - "float64": "Float64", - "inf": "Inf", - "int32": "Int32", - "int64": "Int64", - "nan": "NaN", - "pi": "Pi", - "uint8": "Uint8" - } -} \ No newline at end of file diff --git a/numpy/numpy.go b/numpy/numpy.go deleted file mode 100644 index a8146d45..00000000 --- a/numpy/numpy.go +++ /dev/null @@ -1,9589 +0,0 @@ -package numpy - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -const LLGoPackage = "py.numpy" -// -// Show libraries and system information on which NumPy was built -// and is being used -// -// Parameters -// ---------- -// mode : {`'stdout'`, `'dicts'`}, optional. -// Indicates how to display the config information. -// `'stdout'` prints to console, `'dicts'` returns a dictionary -// of the configuration. -// -// Returns -// ------- -// out : {`dict`, `None`} -// If mode is `'dicts'`, a dict is returned, else None -// -// See Also -// -------- -// get_include : Returns the directory containing NumPy C -// header files. -// -// Notes -// ----- -// 1. The `'stdout'` mode will give more readable -// output if ``pyyaml`` is installed -// -// -// -//go:linkname ShowConfig py.show_config -func ShowConfig(mode *py.Object) *py.Object -// -// Check 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. -// -// Parameters -// ---------- -// a : ndarray -// Input array. -// -// Returns -// ------- -// isfortran : bool -// Returns True if the array is Fortran contiguous but *not* C contiguous. -// -// -// Examples -// -------- -// -// np.array allows to specify whether the array is written in C-contiguous -// order (last index varies the fastest), or FORTRAN-contiguous order in -// memory (first index varies the fastest). -// -// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(a) -// False -// -// >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') -// >>> b -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(b) -// True -// -// -// The transpose of a C-ordered array is a FORTRAN-ordered array. -// -// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(a) -// False -// >>> b = a.T -// >>> b -// array([[1, 4], -// [2, 5], -// [3, 6]]) -// >>> np.isfortran(b) -// True -// -// C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. -// -// >>> np.isfortran(np.array([1, 2], order='F')) -// False -// -// -// -//go:linkname Isfortran py.isfortran -func Isfortran(a *py.Object) *py.Object -// -// Return an array representing the indices of a grid. -// -// Compute an array where the subarrays contain index values 0, 1, ... -// varying only along the corresponding axis. -// -// Parameters -// ---------- -// dimensions : sequence of ints -// The shape of the grid. -// dtype : dtype, optional -// Data type of the result. -// sparse : boolean, optional -// Return a sparse representation of the grid instead of a dense -// representation. Default is False. -// -// .. versionadded:: 1.17 -// -// Returns -// ------- -// grid : one ndarray or tuple of ndarrays -// If sparse is False: -// Returns one array of grid indices, -// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. -// If sparse is True: -// Returns a tuple of arrays, with -// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with -// dimensions[i] in the ith place -// -// See Also -// -------- -// mgrid, ogrid, meshgrid -// -// Notes -// ----- -// The output shape in the dense case is obtained by prepending the number -// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` -// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is -// ``(N, r0, ..., rN-1)``. -// -// The subarrays ``grid[k]`` contains the N-D array of indices along the -// ``k-th`` axis. Explicitly:: -// -// grid[k, i0, i1, ..., iN-1] = ik -// -// Examples -// -------- -// >>> grid = np.indices((2, 3)) -// >>> grid.shape -// (2, 2, 3) -// >>> grid[0] # row indices -// array([[0, 0, 0], -// [1, 1, 1]]) -// >>> grid[1] # column indices -// array([[0, 1, 2], -// [0, 1, 2]]) -// -// The indices can be used as an index into an array. -// -// >>> x = np.arange(20).reshape(5, 4) -// >>> row, col = np.indices((2, 3)) -// >>> x[row, col] -// array([[0, 1, 2], -// [4, 5, 6]]) -// -// Note that it would be more straightforward in the above example to -// extract the required elements directly with ``x[:2, :3]``. -// -// If sparse is set to true, the grid will be returned in a sparse -// representation. -// -// >>> i, j = np.indices((2, 3), sparse=True) -// >>> i.shape -// (2, 1) -// >>> j.shape -// (1, 3) -// >>> i # row indices -// array([[0], -// [1]]) -// >>> j # column indices -// array([[0, 1, 2]]) -// -// -// -//go:linkname Indices py.indices -func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object -// -// Construct an array by executing a function over each coordinate. -// -// The resulting array therefore has a value ``fn(x, y, z)`` at -// coordinate ``(x, y, z)``. -// -// Parameters -// ---------- -// function : callable -// The function is called with N parameters, where N is the rank of -// `shape`. Each parameter represents the coordinates of the array -// varying along a specific axis. For example, if `shape` -// were ``(2, 2)``, then the parameters would be -// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` -// shape : (N,) tuple of ints -// Shape of the output array, which also determines the shape of -// the coordinate arrays passed to `function`. -// dtype : data-type, optional -// Data-type of the coordinate arrays passed to `function`. -// By default, `dtype` is float. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// fromfunction : any -// The result of the call to `function` is passed back directly. -// Therefore the shape of `fromfunction` is completely determined by -// `function`. If `function` returns a scalar value, the shape of -// `fromfunction` would not match the `shape` parameter. -// -// See Also -// -------- -// indices, meshgrid -// -// Notes -// ----- -// Keywords other than `dtype` and `like` are passed to `function`. -// -// Examples -// -------- -// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) -// array([[0., 0.], -// [1., 1.]]) -// -// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) -// array([[0., 1.], -// [0., 1.]]) -// -// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) -// array([[ True, False, False], -// [False, True, False], -// [False, False, True]]) -// -// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) -// array([[0, 1, 2], -// [1, 2, 3], -// [2, 3, 4]]) -// -// -// -//go:linkname Fromfunction py.fromfunction -func Fromfunction(function *py.Object, shape *py.Object) *py.Object -// -// Returns True if the type of `element` is a scalar type. -// -// Parameters -// ---------- -// element : any -// Input argument, can be of any type and shape. -// -// Returns -// ------- -// val : bool -// True if `element` is a scalar type, False if it is not. -// -// See Also -// -------- -// ndim : Get the number of dimensions of an array -// -// Notes -// ----- -// If you need a stricter way to identify a *numerical* scalar, use -// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most -// non-numerical elements such as strings. -// -// In most 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: -// -// +--------------------------------------+---------------+-------------------+ -// | x |``isscalar(x)``|``np.ndim(x) == 0``| -// +======================================+===============+===================+ -// | PEP 3141 numeric objects (including | ``True`` | ``True`` | -// | builtins) | | | -// +--------------------------------------+---------------+-------------------+ -// | builtin string and buffer objects | ``True`` | ``True`` | -// +--------------------------------------+---------------+-------------------+ -// | other builtin objects, like | ``False`` | ``True`` | -// | `pathlib.Path`, `Exception`, | | | -// | the result of `re.compile` | | | -// +--------------------------------------+---------------+-------------------+ -// | third-party objects like | ``False`` | ``True`` | -// | `matplotlib.figure.Figure` | | | -// +--------------------------------------+---------------+-------------------+ -// | zero-dimensional numpy arrays | ``False`` | ``True`` | -// +--------------------------------------+---------------+-------------------+ -// | other numpy arrays | ``False`` | ``False`` | -// +--------------------------------------+---------------+-------------------+ -// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | -// | objects | | | -// +--------------------------------------+---------------+-------------------+ -// -// Examples -// -------- -// >>> np.isscalar(3.1) -// True -// >>> np.isscalar(np.array(3.1)) -// False -// >>> np.isscalar([3.1]) -// False -// >>> np.isscalar(False) -// True -// >>> np.isscalar('numpy') -// True -// -// NumPy supports PEP 3141 numbers: -// -// >>> from fractions import Fraction -// >>> np.isscalar(Fraction(5, 17)) -// True -// >>> from numbers import Number -// >>> np.isscalar(Number()) -// True -// -// -// -//go:linkname Isscalar py.isscalar -func Isscalar(element *py.Object) *py.Object -// -// Return the binary representation of the input number as a string. -// -// For negative numbers, if width is not given, a minus sign is added to the -// front. If width is given, the two's complement of the number is -// returned, with respect to that width. -// -// In a two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit two's-complement -// system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// num : int -// Only an integer decimal number can be used. -// width : int, optional -// The length of the returned string if `num` is positive, or the length -// of the two's complement if `num` is negative, provided that `width` is -// at least a sufficient number of bits for `num` to be represented in the -// designated form. -// -// If the `width` value is insufficient, it will be ignored, and `num` will -// be returned in binary (`num` > 0) or two's complement (`num` < 0) form -// with its width equal to the minimum number of bits needed to represent -// the number in the designated form. This behavior is deprecated and will -// later raise an error. -// -// .. deprecated:: 1.12.0 -// -// Returns -// ------- -// bin : str -// Binary representation of `num` or two's complement of `num`. -// -// See Also -// -------- -// base_repr: Return a string representation of a number in the given base -// system. -// bin: Python's built-in binary representation generator of an integer. -// -// Notes -// ----- -// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x -// faster. -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// >>> np.binary_repr(3) -// '11' -// >>> np.binary_repr(-3) -// '-11' -// >>> np.binary_repr(3, width=4) -// '0011' -// -// The two's complement is returned when the input number is negative and -// width is specified: -// -// >>> np.binary_repr(-3, width=3) -// '101' -// >>> np.binary_repr(-3, width=5) -// '11101' -// -// -// -//go:linkname BinaryRepr py.binary_repr -func BinaryRepr(num *py.Object, width *py.Object) *py.Object -// -// Return a string representation of a number in the given base system. -// -// Parameters -// ---------- -// number : int -// The value to convert. Positive and negative values are handled. -// base : int, optional -// Convert `number` to the `base` number system. The valid range is 2-36, -// the default value is 2. -// padding : int, optional -// Number of zeros padded on the left. Default is 0 (no padding). -// -// Returns -// ------- -// out : str -// String representation of `number` in `base` system. -// -// See Also -// -------- -// binary_repr : Faster version of `base_repr` for base 2. -// -// Examples -// -------- -// >>> np.base_repr(5) -// '101' -// >>> np.base_repr(6, 5) -// '11' -// >>> np.base_repr(7, base=5, padding=3) -// '00012' -// -// >>> np.base_repr(10, base=16) -// 'A' -// >>> np.base_repr(32, base=16) -// '20' -// -// -// -//go:linkname BaseRepr py.base_repr -func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object -// -// Return a new array of given shape and type, filled with ones. -// -// Parameters -// ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// The desired data-type for the array, e.g., `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: C -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of ones with the given shape, dtype, and order. -// -// See Also -// -------- -// ones_like : Return an array of ones with shape and type of input. -// empty : Return a new uninitialized array. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. -// -// -// Examples -// -------- -// >>> np.ones(5) -// array([1., 1., 1., 1., 1.]) -// -// >>> np.ones((5,), dtype=int) -// array([1, 1, 1, 1, 1]) -// -// >>> np.ones((2, 1)) -// array([[1.], -// [1.]]) -// -// >>> s = (2,2) -// >>> np.ones(s) -// array([[1., 1.], -// [1., 1.]]) -// -// -// -//go:linkname Ones py.ones -func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Return the identity array. -// -// The identity array is a square array with ones on -// the main diagonal. -// -// Parameters -// ---------- -// n : int -// Number of rows (and columns) in `n` x `n` output. -// dtype : data-type, optional -// Data-type of the output. Defaults to ``float``. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// `n` x `n` array with its main diagonal set to one, -// and all other elements 0. -// -// Examples -// -------- -// >>> np.identity(3) -// array([[1., 0., 0.], -// [0., 1., 0.], -// [0., 0., 1.]]) -// -// -// -//go:linkname Identity py.identity -func Identity(n *py.Object, dtype *py.Object) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute bit-wise inversion, or bit-wise NOT, element-wise. -// -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. -// -// For signed integer inputs, the two's complement is returned. In a -// two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit -// two's-complement system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Notes -// ----- -// `bitwise_not` is an alias for `invert`: -// -// >>> np.bitwise_not is np.invert -// True -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: -// -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// 242 -// >>> np.binary_repr(x, width=8) -// '11110010' -// -// The result depends on the bit-width: -// -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// 65522 -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types the result is the two's complement of -// the result for the unsigned type: -// -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' -// -// Booleans are accepted as well: -// -// >>> np.invert(np.array([True, False])) -// array([False, True]) -// -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. -// -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) -// -//go:linkname BitwiseNot py.bitwise_not -func BitwiseNot(__llgo_va_list ...interface{}) *py.Object -// -// Return a new array of given shape and type, filled with `fill_value`. -// -// Parameters -// ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// fill_value : scalar or array_like -// Fill value. -// dtype : data-type, optional -// The desired data-type for the array The default, None, means -// ``np.array(fill_value).dtype``. -// order : {'C', 'F'}, optional -// Whether to store multidimensional data in C- or Fortran-contiguous -// (row- or column-wise) order in memory. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of `fill_value` with the given shape, dtype, and order. -// -// See Also -// -------- -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. -// -// Examples -// -------- -// >>> np.full((2, 2), np.inf) -// array([[inf, inf], -// [inf, inf]]) -// >>> np.full((2, 2), 10) -// array([[10, 10], -// [10, 10]]) -// -// >>> np.full((2, 2), [1, 2]) -// array([[1, 2], -// [1, 2]]) -// -// -// -//go:linkname Full py.full -func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object -// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) -// -// Matrix product of two arrays. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays, scalars not allowed. -// out : ndarray, optional -// A location into which the result is stored. If provided, it must have -// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not -// provided or None, a freshly-allocated array is returned. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// .. versionadded:: 1.16 -// Now handles ufunc kwargs -// -// Returns -// ------- -// y : ndarray -// The matrix product of the inputs. -// This is a scalar only when both x1, x2 are 1-d vectors. -// -// Raises -// ------ -// ValueError -// If the last dimension of `x1` is not the same size as -// the second-to-last dimension of `x2`. -// -// If a scalar value is passed in. -// -// See Also -// -------- -// vdot : Complex-conjugating dot product. -// tensordot : Sum products over arbitrary axes. -// einsum : Einstein summation convention. -// dot : alternative matrix product with different broadcasting rules. -// -// Notes -// ----- -// -// The behavior depends on the arguments in the following way. -// -// - If both arguments are 2-D they are multiplied like conventional -// matrices. -// - If either argument is N-D, N > 2, it is treated as a stack of -// matrices residing in the last two indexes and broadcast accordingly. -// - If the first argument is 1-D, it is promoted to a matrix by -// prepending a 1 to its dimensions. After matrix multiplication -// the prepended 1 is removed. -// - If the second argument is 1-D, it is promoted to a matrix by -// appending a 1 to its dimensions. After matrix multiplication -// the appended 1 is removed. -// -// ``matmul`` differs from ``dot`` in two important ways: -// -// - Multiplication by scalars is not allowed, use ``*`` instead. -// - Stacks of matrices are broadcast together as if the matrices -// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: -// -// >>> a = np.ones([9, 5, 7, 4]) -// >>> c = np.ones([9, 5, 4, 3]) -// >>> np.dot(a, c).shape -// (9, 5, 7, 9, 5, 3) -// >>> np.matmul(a, c).shape -// (9, 5, 7, 3) -// >>> # n is 7, k is 4, m is 3 -// -// The matmul function implements the semantics of the ``@`` operator -// introduced in Python 3.5 following :pep:`465`. -// -// It uses an optimized BLAS library when possible (see `numpy.linalg`). -// -// Examples -// -------- -// For 2-D arrays it is the matrix product: -// -// >>> a = np.array([[1, 0], -// ... [0, 1]]) -// >>> b = np.array([[4, 1], -// ... [2, 2]]) -// >>> np.matmul(a, b) -// array([[4, 1], -// [2, 2]]) -// -// For 2-D mixed with 1-D, the result is the usual. -// -// >>> a = np.array([[1, 0], -// ... [0, 1]]) -// >>> b = np.array([1, 2]) -// >>> np.matmul(a, b) -// array([1, 2]) -// >>> np.matmul(b, a) -// array([1, 2]) -// -// -// Broadcasting is conventional for stacks of arrays -// -// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) -// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) -// >>> np.matmul(a,b).shape -// (2, 2, 2) -// >>> np.matmul(a, b)[0, 1, 1] -// 98 -// >>> sum(a[0, 1, :] * b[0 , :, 1]) -// 98 -// -// Vector, vector returns the scalar inner product, but neither argument -// is complex-conjugated: -// -// >>> np.matmul([2j, 3j], [2j, 3j]) -// (-13+0j) -// -// Scalar multiplication raises an error. -// -// >>> np.matmul([1,2], 3) -// Traceback (most recent call last): -// ... -// ValueError: matmul: Input operand 1 does not have enough dimensions ... -// -// The ``@`` operator can be used as a shorthand for ``np.matmul`` on -// ndarrays. -// -// >>> x1 = np.array([2j, 3j]) -// >>> x2 = np.array([2j, 3j]) -// >>> x1 @ x2 -// (-13+0j) -// -// .. versionadded:: 1.10.0 -// -//go:linkname Matmul py.matmul -func Matmul(__llgo_va_list ...interface{}) *py.Object -// arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric inverse cosine, element-wise. -// -// The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``. -// -// Parameters -// ---------- -// x : array_like -// `x`-coordinate on the unit circle. -// For real arguments, the domain is [-1, 1]. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// The angle of the ray intersecting the unit circle at the given -// `x`-coordinate in radians [0, pi]. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// cos, arctan, arcsin, emath.arccos -// -// Notes -// ----- -// `arccos` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``cos(z) = x``. The convention is to return -// the angle `z` whose real part lies in `[0, pi]`. -// -// For real-valued input data types, `arccos` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse `cos` is also known as `acos` or cos^-1. -// -// References -// ---------- -// M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// We expect the arccos of 1 to be 0, and of -1 to be pi: -// -// >>> np.arccos([1, -1]) -// array([ 0. , 3.14159265]) -// -// Plot arccos: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-1, 1, num=100) -// >>> plt.plot(x, np.arccos(x)) -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Arccos py.arccos -func Arccos(__llgo_va_list ...interface{}) *py.Object -// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic cosine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// arccosh : ndarray -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// -// cosh, arcsinh, sinh, arctanh, tanh -// -// Notes -// ----- -// `arccosh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `cosh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in -// ``[0, inf]``. -// -// For real-valued input data types, `arccosh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arccosh` is a complex analytical function that -// has a branch cut `[-inf, 1]` and is continuous from above on it. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arccosh -// -// Examples -// -------- -// >>> np.arccosh([np.e, 10.0]) -// array([ 1.65745445, 2.99322285]) -// >>> np.arccosh(1) -// 0.0 -// -//go:linkname Arccosh py.arccosh -func Arccosh(__llgo_va_list ...interface{}) *py.Object -// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse sine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// `y`-coordinate on the unit circle. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// The inverse sine of each element in `x`, in radians and in the -// closed interval ``[-pi/2, pi/2]``. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin -// -// Notes -// ----- -// `arcsin` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that :math:`sin(z) = x`. The convention is to -// return the angle `z` whose real part lies in [-pi/2, pi/2]. -// -// For real-valued input data types, *arcsin* always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse sine is also known as `asin` or sin^{-1}. -// -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79ff. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// >>> np.arcsin(1) # pi/2 -// 1.5707963267948966 -// >>> np.arcsin(-1) # -pi/2 -// -1.5707963267948966 -// >>> np.arcsin(0) -// 0.0 -// -//go:linkname Arcsin py.arcsin -func Arcsin(__llgo_va_list ...interface{}) *py.Object -// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic sine element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `arcsinh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `sinh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arcsinh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// returns ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arcsinh -// -// Examples -// -------- -// >>> np.arcsinh(np.array([np.e, 10.0])) -// array([ 1.72538256, 2.99822295]) -// -//go:linkname Arcsinh py.arcsinh -func Arcsinh(__llgo_va_list ...interface{}) *py.Object -// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric inverse tangent, element-wise. -// -// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. -// -// Parameters -// ---------- -// x : array_like -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Out has the same shape as `x`. Its real part is in -// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) -// and the positive `x`-axis. -// angle : Argument of complex values. -// -// Notes -// ----- -// `arctan` is a multi-valued function: for each `x` there are infinitely -// many numbers `z` such that tan(`z`) = `x`. The convention is to return -// the angle `z` whose real part lies in [-pi/2, pi/2]. -// -// For real-valued input data types, `arctan` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse tangent is also known as `atan` or tan^{-1}. -// -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// We expect the arctan of 0 to be 0, and of 1 to be pi/4: -// -// >>> np.arctan([0, 1]) -// array([ 0. , 0.78539816]) -// -// >>> np.pi/4 -// 0.78539816339744828 -// -// Plot arctan: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-10, 10) -// >>> plt.plot(x, np.arctan(x)) -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Arctan py.arctan -func Arctan(__llgo_va_list ...interface{}) *py.Object -// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. -// -// 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`). (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). -// -// This function is not defined for complex-valued arguments; for the -// so-called argument of complex values, use `angle`. -// -// Parameters -// ---------- -// x1 : array_like, real-valued -// `y`-coordinates. -// x2 : array_like, real-valued -// `x`-coordinates. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// Array of angles in radians, in the range ``[-pi, pi]``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// arctan, tan, angle -// -// Notes -// ----- -// *arctan2* is identical to the `atan2` function of the underlying -// C library. The following special values are defined in the C -// standard: [1]_ -// -// ====== ====== ================ -// `x1` `x2` `arctan2(x1,x2)` -// ====== ====== ================ -// +/- 0 +0 +/- 0 -// +/- 0 -0 +/- pi -// > 0 +/-inf +0 / +pi -// < 0 +/-inf -0 / -pi -// +/-inf +inf +/- (pi/4) -// +/-inf -inf +/- (3*pi/4) -// ====== ====== ================ -// -// Note that +0 and -0 are distinct floating point numbers, as are +inf -// and -inf. -// -// References -// ---------- -// .. [1] ISO/IEC standard 9899:1999, "Programming language C." -// -// Examples -// -------- -// Consider four points in different quadrants: -// -// >>> x = np.array([-1, +1, +1, -1]) -// >>> y = np.array([-1, -1, +1, +1]) -// >>> np.arctan2(y, x) * 180 / np.pi -// array([-135., -45., 45., 135.]) -// -// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 -// and at several other special points, obtaining values in -// the range ``[-pi, pi]``: -// -// >>> np.arctan2([1., -1.], [0., 0.]) -// array([ 1.57079633, -1.57079633]) -// >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) -// array([0. , 3.14159265, 0.78539816]) -// -//go:linkname Arctan2 py.arctan2 -func Arctan2(__llgo_va_list ...interface{}) *py.Object -// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic tangent element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.arctanh -// -// Notes -// ----- -// `arctanh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``tanh(z) = x``. The convention is to return -// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arctanh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arctanh -// -// Examples -// -------- -// >>> np.arctanh([0, -0.5]) -// array([ 0. , -0.54930614]) -// -//go:linkname Arctanh py.arctanh -func Arctanh(__llgo_va_list ...interface{}) *py.Object -// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise AND of two arrays element-wise. -// -// Computes the bit-wise AND of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``&``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and -// bitwise_or -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise AND of 13 and 17 is -// therefore ``000000001``, or 1: -// -// >>> np.bitwise_and(13, 17) -// 1 -// -// >>> np.bitwise_and(14, 13) -// 12 -// >>> np.binary_repr(12) -// '1100' -// >>> np.bitwise_and([14,3], 13) -// array([12, 1]) -// -// >>> np.bitwise_and([11,7], [4,25]) -// array([0, 1]) -// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) -// array([ 2, 4, 16]) -// >>> np.bitwise_and([True, True], [False, True]) -// array([False, True]) -// -// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([3, 14, 16]) -// >>> x1 & x2 -// array([ 2, 4, 16]) -// -//go:linkname BitwiseAnd py.bitwise_and -func BitwiseAnd(__llgo_va_list ...interface{}) *py.Object -// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise OR of two arrays element-wise. -// -// Computes the bit-wise OR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``|``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_or -// bitwise_and -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 has the binary representation ``00001101``. Likewise, -// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is -// then ``00011101``, or 29: -// -// >>> np.bitwise_or(13, 16) -// 29 -// >>> np.binary_repr(29) -// '11101' -// -// >>> np.bitwise_or(32, 2) -// 34 -// >>> np.bitwise_or([33, 4], 1) -// array([33, 5]) -// >>> np.bitwise_or([33, 4], [1, 2]) -// array([33, 6]) -// -// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) -// array([ 6, 5, 255]) -// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) -// array([ 6, 5, 255]) -// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), -// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) -// array([ 6, 5, 255, 2147483647]) -// >>> np.bitwise_or([True, True], [False, True]) -// array([ True, True]) -// -// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([4, 4, 4]) -// >>> x1 | x2 -// array([ 6, 5, 255]) -// -//go:linkname BitwiseOr py.bitwise_or -func BitwiseOr(__llgo_va_list ...interface{}) *py.Object -// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise XOR of two arrays element-wise. -// -// Computes the bit-wise XOR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``^``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_xor -// bitwise_and -// bitwise_or -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise XOR of 13 and 17 is -// therefore ``00011100``, or 28: -// -// >>> np.bitwise_xor(13, 17) -// 28 -// >>> np.binary_repr(28) -// '11100' -// -// >>> np.bitwise_xor(31, 5) -// 26 -// >>> np.bitwise_xor([31,3], 5) -// array([26, 6]) -// -// >>> np.bitwise_xor([31,3], [5,6]) -// array([26, 5]) -// >>> np.bitwise_xor([True, True], [False, True]) -// array([ True, False]) -// -// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on -// ndarrays. -// -// >>> x1 = np.array([True, True]) -// >>> x2 = np.array([False, True]) -// >>> x1 ^ x2 -// array([ True, False]) -// -//go:linkname BitwiseXor py.bitwise_xor -func BitwiseXor(__llgo_va_list ...interface{}) *py.Object -// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the cube-root of an array, element-wise. -// -// .. versionadded:: 1.10.0 -// -// Parameters -// ---------- -// x : array_like -// The values whose cube-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the cube -// cube-root of each element in `x`. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. -// -// -// Examples -// -------- -// >>> np.cbrt([1,8,27]) -// array([ 1., 2., 3.]) -// -//go:linkname Cbrt py.cbrt -func Cbrt(__llgo_va_list ...interface{}) *py.Object -// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the ceiling of the input, element-wise. -// -// The ceil of the scalar `x` is the smallest integer `i`, such that -// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The ceiling of each element in `x`, with `float` dtype. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// floor, trunc, rint, fix -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.ceil(a) -// array([-1., -1., -0., 1., 2., 2., 2.]) -// -//go:linkname Ceil py.ceil -func Ceil(__llgo_va_list ...interface{}) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the complex conjugate, element-wise. -// -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `conj` is an alias for `conjugate`: -// -// >>> np.conj is np.conjugate -// True -// -// Examples -// -------- -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conj py.conj -func Conj(__llgo_va_list ...interface{}) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the complex conjugate, element-wise. -// -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `conj` is an alias for `conjugate`: -// -// >>> np.conj is np.conjugate -// True -// -// Examples -// -------- -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conjugate py.conjugate -func Conjugate(__llgo_va_list ...interface{}) *py.Object -// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Change the sign of x1 to that of x2, element-wise. -// -// If `x2` is a scalar, its sign will be copied to all elements of `x1`. -// -// Parameters -// ---------- -// x1 : array_like -// Values to change the sign of. -// x2 : array_like -// The sign of `x2` is copied to `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The values of `x1` with the sign of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> np.copysign(1.3, -1) -// -1.3 -// >>> 1/np.copysign(0, 1) -// inf -// >>> 1/np.copysign(0, -1) -// -inf -// -// >>> np.copysign([-1, 0, 1], -1.1) -// array([-1., -0., -1.]) -// >>> np.copysign([-1, 0, 1], np.arange(3)-1) -// array([-1., 0., 1.]) -// -//go:linkname Copysign py.copysign -func Copysign(__llgo_va_list ...interface{}) *py.Object -// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Cosine element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding cosine values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. -// -// Examples -// -------- -// >>> np.cos(np.array([0, np.pi/2, np.pi])) -// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) -// >>> -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Cos py.cos -func Cos(__llgo_va_list ...interface{}) *py.Object -// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Hyperbolic cosine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array of same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.cosh(0) -// 1.0 -// -// The hyperbolic cosine describes the shape of a hanging cable: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-4, 4, 1000) -// >>> plt.plot(x, np.cosh(x)) -// >>> plt.show() -// -//go:linkname Cosh py.cosh -func Cosh(__llgo_va_list ...interface{}) *py.Object -// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from degrees to radians. -// -// Parameters -// ---------- -// x : array_like -// Angles in degrees. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in radians. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// rad2deg : Convert angles from radians to degrees. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// ``deg2rad(x)`` is ``x * pi / 180``. -// -// Examples -// -------- -// >>> np.deg2rad(180) -// 3.1415926535897931 -// -//go:linkname Deg2rad py.deg2rad -func Deg2rad(__llgo_va_list ...interface{}) *py.Object -// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray of floats -// The corresponding degree values; if `out` was supplied this is a -// reference to it. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// rad2deg : equivalent function -// -// Examples -// -------- -// Convert a radian array to degrees -// -// >>> rad = np.arange(12.)*np.pi/6 -// >>> np.degrees(rad) -// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., -// 270., 300., 330.]) -// -// >>> out = np.zeros((rad.shape)) -// >>> r = np.degrees(rad, out) -// >>> np.all(r == out) -// True -// -//go:linkname Degrees py.degrees -func Degrees(__llgo_va_list ...interface{}) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Divide arguments element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. -// -// Examples -// -------- -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.divide(x1, x2) -// array([[nan, 1. , 1. ], -// [inf, 4. , 2.5], -// [inf, 7. , 4. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) -// -//go:linkname Divide py.divide -func Divide(__llgo_va_list ...interface{}) *py.Object -// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return element-wise quotient and remainder simultaneously. -// -// .. versionadded:: 1.13.0 -// -// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster -// because it avoids redundant work. It is used to implement the Python -// built-in function ``divmod`` on NumPy arrays. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out1 : ndarray -// Element-wise quotient resulting from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// out2 : ndarray -// Element-wise remainder from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent to Python's ``//`` operator. -// remainder : Equivalent to Python's ``%`` operator. -// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return -// values switched. -// -// Examples -// -------- -// >>> np.divmod(np.arange(5), 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) -// -// The `divmod` function can be used as a shorthand for ``np.divmod`` on -// ndarrays. -// -// >>> x = np.arange(5) -// >>> divmod(x, 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) -// -//go:linkname Divmod py.divmod -func Divmod(__llgo_va_list ...interface{}) *py.Object -// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return (x1 == x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// not_equal, greater_equal, less_equal, greater, less -// -// Examples -// -------- -// >>> np.equal([0, 1, 3], np.arange(3)) -// array([ True, True, False]) -// -// What is compared are values, not types. So an int (1) and an array of -// length one can evaluate as True: -// -// >>> np.equal(1, np.ones(1)) -// array([ True]) -// -// The ``==`` operator can be used as a shorthand for ``np.equal`` on -// ndarrays. -// -// >>> a = np.array([2, 4, 6]) -// >>> b = np.array([2, 4, 2]) -// >>> a == b -// array([ True, True, False]) -// -//go:linkname Equal py.equal -func Equal(__llgo_va_list ...interface{}) *py.Object -// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the exponential of all elements in the input array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise exponential of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. -// exp2 : Calculate ``2**x`` for all elements in the array. -// -// Notes -// ----- -// The irrational number ``e`` is also known as Euler's number. It is -// approximately 2.718281, and is the base of the natural logarithm, -// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, -// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. -// -// For complex arguments, ``x = a + ib``, we can write -// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already -// known (it is the real argument, described above). The second term, -// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with -// magnitude 1 and a periodic phase. -// -// References -// ---------- -// .. [1] Wikipedia, "Exponential function", -// https://en.wikipedia.org/wiki/Exponential_function -// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions -// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, -// https://personal.math.ubc.ca/~cbm/aands/page_69.htm -// -// Examples -// -------- -// Plot the magnitude and phase of ``exp(x)`` in the complex plane: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) -// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane -// >>> out = np.exp(xx) -// -// >>> plt.subplot(121) -// >>> plt.imshow(np.abs(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') -// >>> plt.title('Magnitude of exp(x)') -// -// >>> plt.subplot(122) -// >>> plt.imshow(np.angle(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') -// >>> plt.title('Phase (angle) of exp(x)') -// >>> plt.show() -// -//go:linkname Exp py.exp -func Exp(__llgo_va_list ...interface{}) *py.Object -// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate `2**p` for all `p` in the input array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise 2 to the power `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// power -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// -// -// Examples -// -------- -// >>> np.exp2([2, 3]) -// array([ 4., 8.]) -// -//go:linkname Exp2 py.exp2 -func Exp2(__llgo_va_list ...interface{}) *py.Object -// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate ``exp(x) - 1`` for all elements in the array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise exponential minus one: ``out = exp(x) - 1``. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log1p : ``log(1 + x)``, the inverse of expm1. -// -// -// Notes -// ----- -// This function provides greater precision than ``exp(x) - 1`` -// for small values of ``x``. -// -// Examples -// -------- -// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to -// about 32 significant digits. This example shows the superiority of -// expm1 in this case. -// -// >>> np.expm1(1e-10) -// 1.00000000005e-10 -// >>> np.exp(1e-10) - 1 -// 1.000000082740371e-10 -// -//go:linkname Expm1 py.expm1 -func Expm1(__llgo_va_list ...interface{}) *py.Object -// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the absolute values element-wise. -// -// This function returns the absolute values (positive magnitude) of the -// data in `x`. Complex values are not handled, use `absolute` to find the -// absolute values of complex data. -// -// Parameters -// ---------- -// x : array_like -// The array of numbers for which the absolute values are required. If -// `x` is a scalar, the result `y` will also be a scalar. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The absolute values of `x`, the returned values are always floats. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// absolute : Absolute values including `complex` types. -// -// Examples -// -------- -// >>> np.fabs(-1) -// 1.0 -// >>> np.fabs([-1.2, 1.2]) -// array([ 1.2, 1.2]) -// -//go:linkname Fabs py.fabs -func Fabs(__llgo_va_list ...interface{}) *py.Object -// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the floor of the input, element-wise. -// -// The floor of the scalar `x` is the largest integer `i`, such that -// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The floor of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ceil, trunc, rint, fix -// -// Notes -// ----- -// Some spreadsheet programs calculate the "floor-towards-zero", where -// ``floor(-2.5) == -2``. NumPy instead uses the definition of -// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" -// function is called ``fix`` in NumPy. -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.floor(a) -// array([-2., -2., -1., 0., 1., 1., 2.]) -// -//go:linkname Floor py.floor -func Floor(__llgo_va_list ...interface{}) *py.Object -// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the largest integer smaller or equal to the division of the inputs. -// It is equivalent to the Python ``//`` operator and pairs with the -// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` -// up to roundoff. -// -// Parameters -// ---------- -// x1 : array_like -// Numerator. -// x2 : array_like -// Denominator. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// y = floor(`x1`/`x2`) -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// remainder : Remainder complementary to floor_divide. -// divmod : Simultaneous floor division and remainder. -// divide : Standard division. -// floor : Round a number to the nearest integer toward minus infinity. -// ceil : Round a number to the nearest integer toward infinity. -// -// Examples -// -------- -// >>> np.floor_divide(7,3) -// 2 -// >>> np.floor_divide([1., 2., 3., 4.], 2.5) -// array([ 0., 0., 1., 1.]) -// -// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` -// on ndarrays. -// -// >>> x1 = np.array([1., 2., 3., 4.]) -// >>> x1 // 2.5 -// array([0., 0., 1., 1.]) -// -//go:linkname FloorDivide py.floor_divide -func FloorDivide(__llgo_va_list ...interface{}) *py.Object -// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// First array elements raised to powers from second array, element-wise. -// -// Raise each base in `x1` to the positionally-corresponding power in `x2`. -// `x1` and `x2` must be broadcastable to the same shape. This differs from -// the power function in that integers, float16, and float32 are promoted to -// floats with a minimum precision of float64 so that the result is always -// inexact. The intent is that the function will return a usable result for -// negative powers and seldom overflow for positive powers. -// -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). -// -// .. versionadded:: 1.12.0 -// -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// power : power function that preserves type -// -// Examples -// -------- -// Cube each element in a list. -// -// >>> x1 = range(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.float_power(x1, 3) -// array([ 0., 1., 8., 27., 64., 125.]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.float_power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.float_power(x1, x2) -// array([[ 0., 1., 8., 27., 16., 5.], -// [ 0., 1., 8., 27., 16., 5.]]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1, -4]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.float_power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.float_power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname FloatPower py.float_power -func FloatPower(__llgo_va_list ...interface{}) *py.Object -// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise maximum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// minimum, amin, nanmin -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. -// -// Examples -// -------- -// >>> np.fmax([2, 3, 4], [1, 5, 2]) -// array([ 2., 5., 4.]) -// -// >>> np.fmax(np.eye(2), [0.5, 2]) -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) -// -// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) -// -//go:linkname Fmax py.fmax -func Fmax(__llgo_va_list ...interface{}) *py.Object -// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise minimum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. -// -// maximum, amax, nanmax -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. -// -// Examples -// -------- -// >>> np.fmin([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) -// -// >>> np.fmin(np.eye(2), [0.5, 2]) -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) -// -// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) -// -//go:linkname Fmin py.fmin -func Fmin(__llgo_va_list ...interface{}) *py.Object -// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// This is the NumPy implementation of the C library function fmod, the -// remainder has the same sign as the dividend `x1`. It is equivalent to -// the Matlab(TM) ``rem`` function and should not be confused with the -// Python modulus operator ``x1 % x2``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend. -// x2 : array_like -// Divisor. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : array_like -// The remainder of the division of `x1` by `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// remainder : Equivalent to the Python ``%`` operator. -// divide -// -// Notes -// ----- -// The result of the modulo operation for negative dividend and divisors -// is bound by conventions. For `fmod`, the sign of result is the sign of -// the dividend, while for `remainder` the sign of the result is the sign -// of the divisor. The `fmod` function is equivalent to the Matlab(TM) -// ``rem`` function. -// -// Examples -// -------- -// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) -// array([-1, 0, -1, 1, 0, 1]) -// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) -// array([1, 0, 1, 1, 0, 1]) -// -// >>> np.fmod([5, 3], [2, 2.]) -// array([ 1., 1.]) -// >>> a = np.arange(-3, 3).reshape(3, 2) -// >>> a -// array([[-3, -2], -// [-1, 0], -// [ 1, 2]]) -// >>> np.fmod(a, [2,2]) -// array([[-1, 0], -// [-1, 0], -// [ 1, 0]]) -// -//go:linkname Fmod py.fmod -func Fmod(__llgo_va_list ...interface{}) *py.Object -// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Decompose the elements of x into mantissa and twos exponent. -// -// Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``. -// The mantissa lies in the open interval(-1, 1), while the twos -// exponent is a signed integer. -// -// Parameters -// ---------- -// x : array_like -// Array of numbers to be decomposed. -// out1 : ndarray, optional -// Output array for the mantissa. Must have the same shape as `x`. -// out2 : ndarray, optional -// Output array for the exponent. Must have the same shape as `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// mantissa : ndarray -// Floating values between -1 and 1. -// This is a scalar if `x` is a scalar. -// exponent : ndarray -// Integer exponents of 2. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`. -// -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. -// -// Examples -// -------- -// >>> x = np.arange(9) -// >>> y1, y2 = np.frexp(x) -// >>> y1 -// array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, -// 0.5 ]) -// >>> y2 -// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) -// >>> y1 * 2**y2 -// array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) -// -//go:linkname Frexp py.frexp -func Frexp(__llgo_va_list ...interface{}) *py.Object -// gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the greatest common divisor of ``|x1|`` and ``|x2|`` -// -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The greatest common divisor of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// lcm : The lowest common multiple -// -// Examples -// -------- -// >>> np.gcd(12, 20) -// 4 -// >>> np.gcd.reduce([15, 25, 35]) -// 5 -// >>> np.gcd(np.arange(6), 20) -// array([20, 1, 2, 1, 4, 5]) -// -//go:linkname Gcd py.gcd -func Gcd(__llgo_va_list ...interface{}) *py.Object -// greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 > x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// -// See Also -// -------- -// greater_equal, less, less_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.greater([4,2],[2,2]) -// array([ True, False]) -// -// The ``>`` operator can be used as a shorthand for ``np.greater`` on -// ndarrays. -// -// >>> a = np.array([4, 2]) -// >>> b = np.array([2, 2]) -// >>> a > b -// array([ True, False]) -// -//go:linkname Greater py.greater -func Greater(__llgo_va_list ...interface{}) *py.Object -// greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 >= x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : bool or ndarray of bool -// 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. -// -// See Also -// -------- -// greater, less, less_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.greater_equal([4, 2, 1], [2, 2, 2]) -// array([ True, True, False]) -// -// The ``>=`` operator can be used as a shorthand for ``np.greater_equal`` -// on ndarrays. -// -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a >= b -// array([ True, True, False]) -// -//go:linkname GreaterEqual py.greater_equal -func GreaterEqual(__llgo_va_list ...interface{}) *py.Object -// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the Heaviside step function. -// -// The Heaviside step function is defined as:: -// -// 0 if x1 < 0 -// heaviside(x1, x2) = x2 if x1 == 0 -// 1 if x1 > 0 -// -// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. -// -// Parameters -// ---------- -// x1 : array_like -// Input values. -// x2 : array_like -// The value of the function when x1 is 0. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The output array, element-wise Heaviside step function of `x1`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// .. versionadded:: 1.13.0 -// -// References -// ---------- -// .. Wikipedia, "Heaviside step function", -// https://en.wikipedia.org/wiki/Heaviside_step_function -// -// Examples -// -------- -// >>> np.heaviside([-1.5, 0, 2.0], 0.5) -// array([ 0. , 0.5, 1. ]) -// >>> np.heaviside([-1.5, 0, 2.0], 1) -// array([ 0., 1., 1.]) -// -//go:linkname Heaviside py.heaviside -func Heaviside(__llgo_va_list ...interface{}) *py.Object -// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Given the "legs" of a right triangle, return its hypotenuse. -// -// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. 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. -// (See Examples) -// -// Parameters -// ---------- -// x1, x2 : array_like -// Leg of the triangle(s). -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// z : ndarray -// The hypotenuse of the triangle(s). -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) -// -// Example showing broadcast of scalar_like argument: -// -// >>> np.hypot(3*np.ones((3, 3)), [4]) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) -// -//go:linkname Hypot py.hypot -func Hypot(__llgo_va_list ...interface{}) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute bit-wise inversion, or bit-wise NOT, element-wise. -// -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. -// -// For signed integer inputs, the two's complement is returned. In a -// two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit -// two's-complement system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Notes -// ----- -// `bitwise_not` is an alias for `invert`: -// -// >>> np.bitwise_not is np.invert -// True -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: -// -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// 242 -// >>> np.binary_repr(x, width=8) -// '11110010' -// -// The result depends on the bit-width: -// -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// 65522 -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types the result is the two's complement of -// the result for the unsigned type: -// -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' -// -// Booleans are accepted as well: -// -// >>> np.invert(np.array([True, False])) -// array([False, True]) -// -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. -// -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) -// -//go:linkname Invert py.invert -func Invert(__llgo_va_list ...interface{}) *py.Object -// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for finiteness (not infinity and not Not a Number). -// -// The result is returned as a boolean array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray, bool -// True where ``x`` is not positive infinity, negative infinity, -// or NaN; false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isinf, isneginf, isposinf, isnan -// -// 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. -// -// Examples -// -------- -// >>> np.isfinite(1) -// True -// >>> np.isfinite(0) -// True -// >>> np.isfinite(np.nan) -// False -// >>> np.isfinite(np.inf) -// False -// >>> np.isfinite(np.NINF) -// False -// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) -// array([False, True, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isfinite(x, y) -// array([0, 1, 0]) -// >>> y -// array([0, 1, 0]) -// -//go:linkname Isfinite py.isfinite -func Isfinite(__llgo_va_list ...interface{}) *py.Object -// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for positive or negative infinity. -// -// Returns a boolean array of the same shape as `x`, True where ``x == -// +/-inf``, otherwise False. -// -// Parameters -// ---------- -// x : array_like -// Input values -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool (scalar) or boolean ndarray -// True where ``x`` is positive or negative infinity, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isneginf, isposinf, isnan, isfinite -// -// 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. -// -// Examples -// -------- -// >>> np.isinf(np.inf) -// True -// >>> np.isinf(np.nan) -// False -// >>> np.isinf(np.NINF) -// True -// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) -// array([ True, True, False, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isinf(x, y) -// array([1, 0, 1]) -// >>> y -// array([1, 0, 1]) -// -//go:linkname Isinf py.isinf -func Isinf(__llgo_va_list ...interface{}) *py.Object -// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for NaN and return result as a boolean array. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaN, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isinf, isneginf, isposinf, isfinite, isnat -// -// 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. -// -// Examples -// -------- -// >>> np.isnan(np.nan) -// True -// >>> np.isnan(np.inf) -// False -// >>> np.isnan([np.log(-1.),1.,np.log(0)]) -// array([ True, False, False]) -// -//go:linkname Isnan py.isnan -func Isnan(__llgo_va_list ...interface{}) *py.Object -// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for NaT (not a time) and return result as a boolean array. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// x : array_like -// Input array with datetime or timedelta data type. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaT, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isnan, isinf, isneginf, isposinf, isfinite -// -// Examples -// -------- -// >>> np.isnat(np.datetime64("NaT")) -// True -// >>> np.isnat(np.datetime64("2016-01-01")) -// False -// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) -// array([ True, False]) -// -//go:linkname Isnat py.isnat -func Isnat(__llgo_va_list ...interface{}) *py.Object -// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` -// -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The lowest common multiple of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// gcd : The greatest common divisor -// -// Examples -// -------- -// >>> np.lcm(12, 20) -// 60 -// >>> np.lcm.reduce([3, 12, 20]) -// 60 -// >>> np.lcm.reduce([40, 12, 20]) -// 120 -// >>> np.lcm(np.arange(6), 20) -// array([ 0, 20, 20, 60, 20, 20]) -// -//go:linkname Lcm py.lcm -func Lcm(__llgo_va_list ...interface{}) *py.Object -// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns x1 * 2**x2, element-wise. -// -// The mantissas `x1` and twos exponents `x2` are used to construct -// floating point numbers ``x1 * 2**x2``. -// -// Parameters -// ---------- -// x1 : array_like -// Array of multipliers. -// x2 : array_like, int -// Array of twos exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The result of ``x1 * 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. -// -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. -// -// `ldexp` is useful as the inverse of `frexp`, if used by itself it is -// more clear to simply use the expression ``x1 * 2**x2``. -// -// Examples -// -------- -// >>> np.ldexp(5, np.arange(4)) -// array([ 5., 10., 20., 40.], dtype=float16) -// -// >>> x = np.arange(6) -// >>> np.ldexp(*np.frexp(x)) -// array([ 0., 1., 2., 3., 4., 5.]) -// -//go:linkname Ldexp py.ldexp -func Ldexp(__llgo_va_list ...interface{}) *py.Object -// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Shift the bits of an integer to the left. -// -// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. -// Since the internal representation of numbers is in binary format, this -// operation is equivalent to multiplying `x1` by ``2**x2``. -// -// Parameters -// ---------- -// x1 : array_like of integer type -// Input values. -// x2 : array_like of integer type -// Number of zeros to append to `x1`. Has to be non-negative. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : array of integer type -// Return `x1` with bits shifted `x2` times to the left. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// right_shift : Shift the bits of an integer to the right. -// binary_repr : Return the binary representation of the input number -// as a string. -// -// Examples -// -------- -// >>> np.binary_repr(5) -// '101' -// >>> np.left_shift(5, 2) -// 20 -// >>> np.binary_repr(20) -// '10100' -// -// >>> np.left_shift(5, [1,2,3]) -// array([10, 20, 40]) -// -// Note that the dtype of the second argument may change the dtype of the -// result and can lead to unexpected results in some cases (see -// :ref:`Casting Rules `): -// -// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 -// >>> print(a, type(a)) # Unexpected result due to upcasting -// 510 -// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) -// >>> print(b, type(b)) -// 254 -// -// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on -// ndarrays. -// -// >>> x1 = 5 -// >>> x2 = np.array([1, 2, 3]) -// >>> x1 << x2 -// array([10, 20, 40]) -// -//go:linkname LeftShift py.left_shift -func LeftShift(__llgo_va_list ...interface{}) *py.Object -// less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 < x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// greater, less_equal, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.less([1, 2], [2, 2]) -// array([ True, False]) -// -// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. -// -// >>> a = np.array([1, 2]) -// >>> b = np.array([2, 2]) -// >>> a < b -// array([ True, False]) -// -//go:linkname Less py.less -func Less(__llgo_va_list ...interface{}) *py.Object -// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 <= x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// greater, less, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.less_equal([4, 2, 1], [2, 2, 2]) -// array([False, True, True]) -// -// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on -// ndarrays. -// -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a <= b -// array([False, True, True]) -// -//go:linkname LessEqual py.less_equal -func LessEqual(__llgo_va_list ...interface{}) *py.Object -// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Natural logarithm, element-wise. -// -// The natural logarithm `log` is the inverse of the exponential function, -// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base -// `e`. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The natural logarithm of `x`, element-wise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log10, log2, log1p, emath.log -// -// Notes -// ----- -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `exp(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log` always returns real output. For -// each value that cannot be expressed as a real number or infinity, it -// yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. `log` -// handles the floating-point negative zero as an infinitesimal negative -// number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log([1, np.e, np.e**2, 0]) -// array([ 0., 1., 2., -Inf]) -// -//go:linkname Log py.log -func Log(__llgo_va_list ...interface{}) *py.Object -// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the base 10 logarithm of the input array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The logarithm to the base 10 of `x`, element-wise. NaNs are -// returned where x is negative. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.log10 -// -// Notes -// ----- -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `10**z = x`. The convention is to return the -// `z` whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log10` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log10` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. -// `log10` handles the floating-point negative zero as an infinitesimal -// negative number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log10([1e-15, -3.]) -// array([-15., nan]) -// -//go:linkname Log10 py.log10 -func Log10(__llgo_va_list ...interface{}) *py.Object -// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the natural logarithm of one plus the input array, element-wise. -// -// Calculates ``log(1 + x)``. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Natural logarithm of `1 + x`, element-wise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// expm1 : ``exp(x) - 1``, the inverse of `log1p`. -// -// Notes -// ----- -// For real-valued input, `log1p` is accurate also for `x` so small -// that `1 + x == 1` in floating-point accuracy. -// -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `exp(z) = 1 + x`. The convention is to return -// the `z` whose imaginary part lies in `[-pi, pi]`. -// -// For real-valued input data types, `log1p` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log1p` is a complex analytical function that -// has a branch cut `[-inf, -1]` and is continuous from above on it. -// `log1p` handles the floating-point negative zero as an infinitesimal -// negative number, conforming to the C99 standard. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log1p(1e-99) -// 1e-99 -// >>> np.log(1 + 1e-99) -// 0.0 -// -//go:linkname Log1p py.log1p -func Log1p(__llgo_va_list ...interface{}) *py.Object -// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Base-2 logarithm of `x`. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Base-2 logarithm of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log, log10, log1p, emath.log2 -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `2**z = x`. The convention is to return the `z` -// whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log2` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log2` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` -// handles the floating-point negative zero as an infinitesimal negative -// number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// Examples -// -------- -// >>> x = np.array([0, 1, 2, 2**4]) -// >>> np.log2(x) -// array([-Inf, 0., 1., 4.]) -// -// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) -// >>> np.log2(xi) -// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) -// -//go:linkname Log2 py.log2 -func Log2(__llgo_va_list ...interface{}) *py.Object -// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Logarithm of the sum of exponentiations of the inputs. -// -// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in -// statistics where the calculated probabilities of events may be so small -// as to exceed the range of normal floating point numbers. In such cases -// the logarithm of the calculated probability is stored. This function -// allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Logarithm of ``exp(x1) + exp(x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> prob1 = np.log(1e-50) -// >>> prob2 = np.log(2.5e-50) -// >>> prob12 = np.logaddexp(prob1, prob2) -// >>> prob12 -// -113.87649168120691 -// >>> np.exp(prob12) -// 3.5000000000000057e-50 -// -//go:linkname Logaddexp py.logaddexp -func Logaddexp(__llgo_va_list ...interface{}) *py.Object -// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Logarithm of the sum of exponentiations of the inputs in base-2. -// -// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine -// learning when the calculated probabilities of events may be so small as -// to exceed the range of normal floating point numbers. In such cases -// the base-2 logarithm of the calculated probability can be used instead. -// This function allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Base-2 logarithm of ``2**x1 + 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp: Logarithm of the sum of exponentiations of the inputs. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> prob1 = np.log2(1e-50) -// >>> prob2 = np.log2(2.5e-50) -// >>> prob12 = np.logaddexp2(prob1, prob2) -// >>> prob1, prob2, prob12 -// (-166.09640474436813, -164.77447664948076, -164.28904982231052) -// >>> 2**prob12 -// 3.4999999999999914e-50 -// -//go:linkname Logaddexp2 py.logaddexp2 -func Logaddexp2(__llgo_va_list ...interface{}) *py.Object -// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 AND x2 element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical AND operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_or, logical_not, logical_xor -// bitwise_and -// -// Examples -// -------- -// >>> np.logical_and(True, False) -// False -// >>> np.logical_and([True, False], [False, False]) -// array([False, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_and(x>1, x<4) -// array([False, False, True, True, False]) -// -// -// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on -// boolean ndarrays. -// -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a & b -// array([False, False]) -// -//go:linkname LogicalAnd py.logical_and -func LogicalAnd(__llgo_va_list ...interface{}) *py.Object -// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of NOT x element-wise. -// -// Parameters -// ---------- -// x : array_like -// Logical NOT is applied to the elements of `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool or ndarray of bool -// 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. -// -// See Also -// -------- -// logical_and, logical_or, logical_xor -// -// Examples -// -------- -// >>> np.logical_not(3) -// False -// >>> np.logical_not([True, False, 0, 1]) -// array([False, True, True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_not(x<3) -// array([False, False, False, True, True]) -// -//go:linkname LogicalNot py.logical_not -func LogicalNot(__llgo_va_list ...interface{}) *py.Object -// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 OR x2 element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Logical OR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical OR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and, logical_not, logical_xor -// bitwise_or -// -// Examples -// -------- -// >>> np.logical_or(True, False) -// True -// >>> np.logical_or([True, False], [False, False]) -// array([ True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_or(x < 1, x > 3) -// array([ True, False, False, False, True]) -// -// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on -// boolean ndarrays. -// -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a | b -// array([ True, False]) -// -//go:linkname LogicalOr py.logical_or -func LogicalOr(__llgo_va_list ...interface{}) *py.Object -// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 XOR x2, element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Logical XOR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool or ndarray of bool -// Boolean result of the logical XOR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and, logical_or, logical_not, bitwise_xor -// -// Examples -// -------- -// >>> np.logical_xor(True, False) -// True -// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) -// array([False, True, True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_xor(x < 1, x > 3) -// array([ True, False, False, False, True]) -// -// Simple example showing support of broadcasting -// -// >>> np.logical_xor(0, np.eye(2)) -// array([[ True, False], -// [False, True]]) -// -//go:linkname LogicalXor py.logical_xor -func LogicalXor(__llgo_va_list ...interface{}) *py.Object -// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise maximum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// fmin, amin, nanmin -// -// Notes -// ----- -// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when -// neither x1 nor x2 are nans, but it is faster and does proper -// broadcasting. -// -// Examples -// -------- -// >>> np.maximum([2, 3, 4], [1, 5, 2]) -// array([2, 5, 4]) -// -// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) -// -// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.maximum(np.Inf, 1) -// inf -// -//go:linkname Maximum py.maximum -func Maximum(__llgo_va_list ...interface{}) *py.Object -// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise minimum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. -// -// fmax, amax, nanmax -// -// Notes -// ----- -// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when -// neither x1 nor x2 are NaNs, but it is faster and does proper -// broadcasting. -// -// Examples -// -------- -// >>> np.minimum([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) -// -// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) -// -// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.minimum(-np.Inf, 1) -// -inf -// -//go:linkname Minimum py.minimum -func Minimum(__llgo_va_list ...interface{}) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. -// -// .. warning:: -// -// This should not be confused with: -// -// * Python 3.7's `math.remainder` and C's ``remainder``, which -// computes the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor -// -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. -// -// Examples -// -------- -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) -// -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. -// -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) -// -//go:linkname Mod py.mod -func Mod(__llgo_va_list ...interface{}) *py.Object -// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the fractional and integral parts of an array, element-wise. -// -// The fractional and integral parts are negative if the given number is -// negative. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y1 : ndarray -// Fractional part of `x`. -// This is a scalar if `x` is a scalar. -// y2 : ndarray -// Integral part of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// For integer input the return values are floats. -// -// See Also -// -------- -// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values -// switched, except it always has a positive remainder. -// -// Examples -// -------- -// >>> np.modf([0, 3.5]) -// (array([ 0. , 0.5]), array([ 0., 3.])) -// >>> np.modf(-0.5) -// (-0.5, -0) -// -//go:linkname Modf py.modf -func Modf(__llgo_va_list ...interface{}) *py.Object -// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Multiply arguments element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays to be multiplied. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The product of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to `x1` * `x2` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.multiply(2.0, 4.0) -// 8.0 -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.multiply(x1, x2) -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) -// -// The ``*`` operator can be used as a shorthand for ``np.multiply`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 * x2 -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) -// -//go:linkname Multiply py.multiply -func Multiply(__llgo_va_list ...interface{}) *py.Object -// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Numerical negative, element-wise. -// -// Parameters -// ---------- -// x : array_like or scalar -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// Returned array or scalar: `y = -x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.negative([1.,-1.]) -// array([-1., 1.]) -// -// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> -x1 -// array([-1., 1.]) -// -//go:linkname Negative py.negative -func Negative(__llgo_va_list ...interface{}) *py.Object -// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the next floating-point value after x1 towards x2, element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Values to find the next representable value of. -// x2 : array_like -// The direction where to look for the next representable value of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The next representable values of `x1` in the direction of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> eps = np.finfo(np.float64).eps -// >>> np.nextafter(1, 2) == eps + 1 -// True -// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] -// array([ True, True]) -// -//go:linkname Nextafter py.nextafter -func Nextafter(__llgo_va_list ...interface{}) *py.Object -// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return (x1 != x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// equal, greater, greater_equal, less, less_equal -// -// Examples -// -------- -// >>> np.not_equal([1.,2.], [1., 3.]) -// array([False, True]) -// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) -// array([[False, True], -// [False, True]]) -// -// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on -// ndarrays. -// -// >>> a = np.array([1., 2.]) -// >>> b = np.array([1., 3.]) -// >>> a != b -// array([False, True]) -// -//go:linkname NotEqual py.not_equal -func NotEqual(__llgo_va_list ...interface{}) *py.Object -// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Numerical positive, element-wise. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// x : array_like or scalar -// Input array. -// -// Returns -// ------- -// y : ndarray or scalar -// Returned array or scalar: `y = +x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// Equivalent to `x.copy()`, but only defined for types that support -// arithmetic. -// -// Examples -// -------- -// -// >>> x1 = np.array(([1., -1.])) -// >>> np.positive(x1) -// array([ 1., -1.]) -// -// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> +x1 -// array([ 1., -1.]) -// -//go:linkname Positive py.positive -func Positive(__llgo_va_list ...interface{}) *py.Object -// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// First array elements raised to powers from second array, element-wise. -// -// Raise each base in `x1` to the positionally-corresponding power in -// `x2`. `x1` and `x2` must be broadcastable to the same shape. -// -// An integer type raised to a negative integer power will raise a -// ``ValueError``. -// -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). -// -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// float_power : power function that promotes integers to float -// -// Examples -// -------- -// Cube each element in an array. -// -// >>> x1 = np.arange(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.power(x1, 3) -// array([ 0, 1, 8, 27, 64, 125]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.power(x1, x2) -// array([[ 0, 1, 8, 27, 16, 5], -// [ 0, 1, 8, 27, 16, 5]]) -// -// The ``**`` operator can be used as a shorthand for ``np.power`` on -// ndarrays. -// -// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) -// >>> x1 = np.arange(6) -// >>> x1 ** x2 -// array([ 0, 1, 8, 27, 16, 5]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1.0, -4.0]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname Power py.power -func Power(__llgo_va_list ...interface{}) *py.Object -// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Angle in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in degrees. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : Convert angles from degrees to radians. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// rad2deg(x) is ``180 * x / pi``. -// -// Examples -// -------- -// >>> np.rad2deg(np.pi/2) -// 90.0 -// -//go:linkname Rad2deg py.rad2deg -func Rad2deg(__llgo_va_list ...interface{}) *py.Object -// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from degrees to radians. -// -// Parameters -// ---------- -// x : array_like -// Input array in degrees. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding radian values. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : equivalent function -// -// Examples -// -------- -// Convert a degree array to radians -// -// >>> deg = np.arange(12.) * 30. -// >>> np.radians(deg) -// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , -// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, -// 5.23598776, 5.75958653]) -// -// >>> out = np.zeros((deg.shape)) -// >>> ret = np.radians(deg, out) -// >>> ret is out -// True -// -//go:linkname Radians py.radians -func Radians(__llgo_va_list ...interface{}) *py.Object -// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the reciprocal of the argument, element-wise. -// -// Calculates ``1/x``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Return array. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// .. note:: -// This function is not designed to work with integers. -// -// For integer arguments with absolute value larger than 1 the result is -// always zero because of the way Python handles integer division. For -// integer zero the result is an overflow. -// -// Examples -// -------- -// >>> np.reciprocal(2.) -// 0.5 -// >>> np.reciprocal([1, 2., 3.33]) -// array([ 1. , 0.5 , 0.3003003]) -// -//go:linkname Reciprocal py.reciprocal -func Reciprocal(__llgo_va_list ...interface{}) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. -// -// .. warning:: -// -// This should not be confused with: -// -// * Python 3.7's `math.remainder` and C's ``remainder``, which -// computes the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor -// -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. -// -// Examples -// -------- -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) -// -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. -// -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) -// -//go:linkname Remainder py.remainder -func Remainder(__llgo_va_list ...interface{}) *py.Object -// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Shift the bits of an integer to the right. -// -// Bits are shifted to the right `x2`. Because the internal -// representation of numbers is in binary format, this operation is -// equivalent to dividing `x1` by ``2**x2``. -// -// Parameters -// ---------- -// x1 : array_like, int -// Input values. -// x2 : array_like, int -// Number of bits to remove at the right of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray, int -// Return `x1` with bits shifted `x2` times to the right. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// left_shift : Shift the bits of an integer to the left. -// binary_repr : Return the binary representation of the input number -// as a string. -// -// Examples -// -------- -// >>> np.binary_repr(10) -// '1010' -// >>> np.right_shift(10, 1) -// 5 -// >>> np.binary_repr(5) -// '101' -// -// >>> np.right_shift(10, [1,2,3]) -// array([5, 2, 1]) -// -// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on -// ndarrays. -// -// >>> x1 = 10 -// >>> x2 = np.array([1,2,3]) -// >>> x1 >> x2 -// array([5, 2, 1]) -// -//go:linkname RightShift py.right_shift -func RightShift(__llgo_va_list ...interface{}) *py.Object -// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Round elements of the array to the nearest integer. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array is same shape and type as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// fix, ceil, floor, trunc -// -// Notes -// ----- -// For values exactly halfway between rounded decimal values, NumPy -// rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, -// -0.5 and 0.5 round to 0.0, etc. -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.rint(a) -// array([-2., -2., -0., 0., 2., 2., 2.]) -// -//go:linkname Rint py.rint -func Rint(__llgo_va_list ...interface{}) *py.Object -// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns an element-wise indication of the sign of a number. -// -// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan -// is returned for nan inputs. -// -// For complex inputs, the `sign` function returns -// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. -// -// complex(nan, 0) is returned for complex nan inputs. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The sign of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// There is more than one definition of sign in common use for complex -// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` -// which is different from a common alternative, :math:`x/|x|`. -// -// Examples -// -------- -// >>> np.sign([-5., 4.5]) -// array([-1., 1.]) -// >>> np.sign(0) -// 0 -// >>> np.sign(5-2j) -// (1+0j) -// -//go:linkname Sign py.sign -func Sign(__llgo_va_list ...interface{}) *py.Object -// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns element-wise True where signbit is set (less than zero). -// -// Parameters -// ---------- -// x : array_like -// The input value(s). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray of bool -// Output array, or reference to `out` if that was supplied. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.signbit(-1.2) -// True -// >>> np.signbit(np.array([1, -2.3, 2.1])) -// array([False, True, False]) -// -//go:linkname Signbit py.signbit -func Signbit(__llgo_va_list ...interface{}) *py.Object -// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric sine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : array_like -// The sine of each element of x. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// arcsin, sinh, cos -// -// Notes -// ----- -// The sine is one of the fundamental functions of trigonometry (the -// mathematical study of triangles). Consider a circle of radius 1 -// centered on the origin. A ray comes in from the :math:`+x` axis, makes -// an angle at the origin (measured counter-clockwise from that axis), and -// departs from the origin. The :math:`y` coordinate of the outgoing -// ray's intersection with the unit circle is the sine of that angle. It -// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The -// function has zeroes where the angle is a multiple of :math:`\pi`. -// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. -// The numerous properties of the sine and related functions are included -// in any standard trigonometry text. -// -// Examples -// -------- -// Print sine of one angle: -// -// >>> np.sin(np.pi/2.) -// 1.0 -// -// Print sines of an array of angles given in degrees: -// -// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) -// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) -// -// Plot the sine function: -// -// >>> import matplotlib.pylab as plt -// >>> x = np.linspace(-np.pi, np.pi, 201) -// >>> plt.plot(x, np.sin(x)) -// >>> plt.xlabel('Angle [rad]') -// >>> plt.ylabel('sin(x)') -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Sin py.sin -func Sin(__llgo_va_list ...interface{}) *py.Object -// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Hyperbolic sine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or -// ``-1j * np.sin(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding hyperbolic sine values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// -// Examples -// -------- -// >>> np.sinh(0) -// 0.0 -// >>> np.sinh(np.pi*1j/2) -// 1j -// >>> np.sinh(np.pi*1j) # (exact value is 0) -// 1.2246063538223773e-016j -// >>> # Discrepancy due to vagaries of floating point arithmetic. -// -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.sinh([0.1], out1) -// >>> out2 is out1 -// True -// -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Sinh py.sinh -func Sinh(__llgo_va_list ...interface{}) *py.Object -// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the distance between x and the nearest adjacent number. -// -// Parameters -// ---------- -// x : array_like -// Values to find the spacing of. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The spacing of values of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// It can be considered as a generalization of EPS: -// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there -// should not be any representable number between ``x + spacing(x)`` and -// x for any finite x. -// -// Spacing of +- inf and NaN is NaN. -// -// Examples -// -------- -// >>> np.spacing(1) == np.finfo(np.float64).eps -// True -// -//go:linkname Spacing py.spacing -func Spacing(__llgo_va_list ...interface{}) *py.Object -// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the non-negative square-root of an array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// The values whose square-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the positive -// square-root of each element in `x`. If any element in `x` is -// complex, a complex array is returned (and the square-roots of -// negative reals are calculated). If all of the elements in `x` -// are real, so is `y`, with negative elements returning ``nan``. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.sqrt -// A version which returns complex numbers when given negative reals. -// Note that 0.0 and -0.0 are handled differently for complex inputs. -// -// Notes -// ----- -// *sqrt* has--consistent with common convention--as its branch cut the -// real "interval" [`-inf`, 0), and is continuous from above on it. -// A branch cut is a curve in the complex plane across which a given -// complex function fails to be continuous. -// -// Examples -// -------- -// >>> np.sqrt([1,4,9]) -// array([ 1., 2., 3.]) -// -// >>> np.sqrt([4, -1, -3+4J]) -// array([ 2.+0.j, 0.+1.j, 1.+2.j]) -// -// >>> np.sqrt([4, -1, np.inf]) -// array([ 2., nan, inf]) -// -//go:linkname Sqrt py.sqrt -func Sqrt(__llgo_va_list ...interface{}) *py.Object -// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the element-wise square of the input. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise `x*x`, of the same shape and dtype as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// numpy.linalg.matrix_power -// sqrt -// power -// -// Examples -// -------- -// >>> np.square([-1j, 1]) -// array([-1.-0.j, 1.+0.j]) -// -//go:linkname Square py.square -func Square(__llgo_va_list ...interface{}) *py.Object -// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Subtract arguments, element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays to be subtracted from each other. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The difference of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to ``x1 - x2`` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.subtract(1.0, 4.0) -// -3.0 -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.subtract(x1, x2) -// array([[ 0., 0., 0.], -// [ 3., 3., 3.], -// [ 6., 6., 6.]]) -// -// The ``-`` operator can be used as a shorthand for ``np.subtract`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 - x2 -// array([[0., 0., 0.], -// [3., 3., 3.], -// [6., 6., 6.]]) -// -//go:linkname Subtract py.subtract -func Subtract(__llgo_va_list ...interface{}) *py.Object -// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute tangent element-wise. -// -// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding tangent values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. -// -// Examples -// -------- -// >>> from math import pi -// >>> np.tan(np.array([-pi,pi/2,pi])) -// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) -// >>> -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Tan py.tan -func Tan(__llgo_va_list ...interface{}) *py.Object -// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute hyperbolic tangent element-wise. -// -// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding hyperbolic tangent values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// https://personal.math.ubc.ca/~cbm/aands/page_83.htm -// -// .. [2] Wikipedia, "Hyperbolic function", -// https://en.wikipedia.org/wiki/Hyperbolic_function -// -// Examples -// -------- -// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) -// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) -// -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.tanh([0.1], out1) -// >>> out2 is out1 -// True -// -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Tanh py.tanh -func Tanh(__llgo_va_list ...interface{}) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Divide arguments element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. -// -// Examples -// -------- -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.divide(x1, x2) -// array([[nan, 1. , 1. ], -// [inf, 4. , 2.5], -// [inf, 7. , 4. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) -// -//go:linkname TrueDivide py.true_divide -func TrueDivide(__llgo_va_list ...interface{}) *py.Object -// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truncated value of the input, element-wise. -// -// The truncated value of the scalar `x` is the nearest integer `i` which -// is closer to zero than `x` is. In short, the fractional part of the -// signed number `x` is discarded. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The truncated value of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ceil, floor, rint, fix -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.trunc(a) -// array([-1., -1., -0., 0., 1., 1., 2.]) -// -//go:linkname Trunc py.trunc -func Trunc(__llgo_va_list ...interface{}) *py.Object -// -// Return the scalar dtype or NumPy equivalent of Python type of an object. -// -// Parameters -// ---------- -// rep : any -// The object of which the type is returned. -// default : any, optional -// If given, this is returned for objects whose types can not be -// determined. If not given, None is returned for those objects. -// -// Returns -// ------- -// dtype : dtype or Python type -// The data type of `rep`. -// -// See Also -// -------- -// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype -// -// Examples -// -------- -// >>> np.obj2sctype(np.int32) -// -// >>> np.obj2sctype(np.array([1., 2.])) -// -// >>> np.obj2sctype(np.array([1.j])) -// -// -// >>> np.obj2sctype(dict) -// -// >>> np.obj2sctype('string') -// -// >>> np.obj2sctype(1, default=list) -// -// -// -// -//go:linkname Obj2sctype py.obj2sctype -func Obj2sctype(rep *py.Object, default_ *py.Object) *py.Object -// -// Return the string representation of a scalar dtype. -// -// Parameters -// ---------- -// sctype : scalar dtype or object -// If a scalar dtype, the corresponding string character is -// returned. If an object, `sctype2char` tries to infer its scalar type -// and then return the corresponding string character. -// -// Returns -// ------- -// typechar : str -// The string character corresponding to the scalar type. -// -// Raises -// ------ -// ValueError -// If `sctype` is an object for which the type can not be inferred. -// -// See Also -// -------- -// obj2sctype, issctype, issubsctype, mintypecode -// -// Examples -// -------- -// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: -// ... print(np.sctype2char(sctype)) -// l # may vary -// d -// D -// S -// O -// -// >>> x = np.array([1., 2-1.j]) -// >>> np.sctype2char(x) -// 'D' -// >>> np.sctype2char(list) -// 'O' -// -// -// -//go:linkname Sctype2char py.sctype2char -func Sctype2char(sctype *py.Object) *py.Object -// -// Return the scalar type of highest precision of the same kind as the input. -// -// Parameters -// ---------- -// t : dtype or dtype specifier -// The input data type. This can be a `dtype` object or an object that -// is convertible to a `dtype`. -// -// Returns -// ------- -// out : dtype -// The highest precision data type of the same kind (`dtype.kind`) as `t`. -// -// See Also -// -------- -// obj2sctype, mintypecode, sctype2char -// dtype -// -// Examples -// -------- -// >>> np.maximum_sctype(int) -// -// >>> np.maximum_sctype(np.uint8) -// -// >>> np.maximum_sctype(complex) -// # may vary -// -// >>> np.maximum_sctype(str) -// -// -// >>> np.maximum_sctype('i2') -// -// >>> np.maximum_sctype('f4') -// # may vary -// -// -// -//go:linkname MaximumSctype py.maximum_sctype -func MaximumSctype(t *py.Object) *py.Object -// -// Determines whether the given object represents a scalar data-type. -// -// Parameters -// ---------- -// rep : any -// If `rep` is an instance of a scalar dtype, True is returned. If not, -// False is returned. -// -// Returns -// ------- -// out : bool -// Boolean result of check whether `rep` is a scalar dtype. -// -// See Also -// -------- -// issubsctype, issubdtype, obj2sctype, sctype2char -// -// Examples -// -------- -// >>> np.issctype(np.int32) -// True -// >>> np.issctype(list) -// False -// >>> np.issctype(1.1) -// False -// -// Strings are also a scalar type: -// -// >>> np.issctype(np.dtype('str')) -// True -// -// -// -//go:linkname Issctype py.issctype -func Issctype(rep *py.Object) *py.Object -// -// Determine common type following standard coercion rules. -// -// .. deprecated:: NumPy 1.25 -// -// This function is deprecated, use `numpy.promote_types` or -// `numpy.result_type` instead. To achieve semantics for the -// `scalar_types` argument, use `numpy.result_type` and pass the Python -// values `0`, `0.0`, or `0j`. -// This will give the same results in almost all cases. -// More information and rare exception can be found in the -// `NumPy 1.25 release notes `_. -// -// Parameters -// ---------- -// array_types : sequence -// A list of dtypes or dtype convertible objects representing arrays. -// scalar_types : sequence -// A list of dtypes or dtype convertible objects representing scalars. -// -// Returns -// ------- -// datatype : dtype -// The common data type, which is the maximum of `array_types` ignoring -// `scalar_types`, unless the maximum of `scalar_types` is of a -// different kind (`dtype.kind`). If the kind is not understood, then -// None is returned. -// -// See Also -// -------- -// dtype, common_type, can_cast, mintypecode -// -// Examples -// -------- -// >>> np.find_common_type([], [np.int64, np.float32, complex]) -// dtype('complex128') -// >>> np.find_common_type([np.int64, np.float32], []) -// dtype('float64') -// -// The standard casting rules ensure that a scalar cannot up-cast an -// array unless the scalar is of a fundamentally different kind of data -// (i.e. under a different hierarchy in the data type hierarchy) then -// the array: -// -// >>> np.find_common_type([np.float32], [np.int64, np.float64]) -// dtype('float32') -// -// Complex is of a different type, so it up-casts the float in the -// `array_types` argument: -// -// >>> np.find_common_type([np.float32], [complex]) -// dtype('complex128') -// -// Type specifier strings are convertible to dtypes and can therefore -// be used instead of dtypes: -// -// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) -// dtype('complex128') -// -// -// -//go:linkname FindCommonType py.find_common_type -func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object -// -// Returns True if first argument is a typecode lower/equal in type hierarchy. -// -// This is like the builtin :func:`issubclass`, but for `dtype`\ s. -// -// Parameters -// ---------- -// arg1, arg2 : dtype_like -// `dtype` or object coercible to one -// -// Returns -// ------- -// out : bool -// -// See Also -// -------- -// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. -// issubsctype, issubclass_ -// -// Examples -// -------- -// `issubdtype` can be used to check the type of arrays: -// -// >>> ints = np.array([1, 2, 3], dtype=np.int32) -// >>> np.issubdtype(ints.dtype, np.integer) -// True -// >>> np.issubdtype(ints.dtype, np.floating) -// False -// -// >>> floats = np.array([1, 2, 3], dtype=np.float32) -// >>> np.issubdtype(floats.dtype, np.integer) -// False -// >>> np.issubdtype(floats.dtype, np.floating) -// True -// -// Similar types of different sizes are not subdtypes of each other: -// -// >>> np.issubdtype(np.float64, np.float32) -// False -// >>> np.issubdtype(np.float32, np.float64) -// False -// -// but both are subtypes of `floating`: -// -// >>> np.issubdtype(np.float64, np.floating) -// True -// >>> np.issubdtype(np.float32, np.floating) -// True -// -// For convenience, dtype-like objects are allowed too: -// -// >>> np.issubdtype('S1', np.string_) -// True -// >>> np.issubdtype('i4', np.signedinteger) -// True -// -// -// -//go:linkname Issubdtype py.issubdtype -func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Set a Python function to be used when pretty printing arrays. -// -// Parameters -// ---------- -// f : function or None -// Function to be used to pretty print arrays. The function should expect -// a single array argument and return a string of the representation of -// the array. If None, the function is reset to the default NumPy function -// to print arrays. -// repr : bool, optional -// If True (default), the function for pretty printing (``__repr__``) -// is set, if False the function that returns the default string -// representation (``__str__``) is set. -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// Examples -// -------- -// >>> def pprint(arr): -// ... return 'HA! - What are you going to do now?' -// ... -// >>> np.set_string_function(pprint) -// >>> a = np.arange(10) -// >>> a -// HA! - What are you going to do now? -// >>> _ = a -// >>> # [0 1 2 3 4 5 6 7 8 9] -// -// We can reset the function to the default: -// -// >>> np.set_string_function(None) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// -// `repr` affects either pretty printing or normal string representation. -// Note that ``__repr__`` is still affected by setting ``__str__`` -// because the width of each array element in the returned string becomes -// equal to the length of the result of ``__str__()``. -// -// >>> x = np.arange(4) -// >>> np.set_string_function(lambda x:'random', repr=False) -// >>> x.__str__() -// 'random' -// >>> x.__repr__() -// 'array([0, 1, 2, 3])' -// -// -// -//go:linkname SetStringFunction py.set_string_function -func SetStringFunction(f *py.Object, repr *py.Object) *py.Object -// -// Set printing options. -// -// These options determine the way floating point numbers, arrays and -// other NumPy objects are displayed. -// -// Parameters -// ---------- -// precision : int or None, optional -// Number of digits of precision for floating point output (default 8). -// May be None if `floatmode` is not `fixed`, to print as many digits as -// necessary to uniquely specify the value. -// threshold : int, optional -// Total number of array elements which trigger summarization -// rather than full repr (default 1000). -// To always use the full repr without summarization, pass `sys.maxsize`. -// edgeitems : int, optional -// Number of array items in summary at beginning and end of -// each dimension (default 3). -// linewidth : int, optional -// The number of characters per line for the purpose of inserting -// line breaks (default 75). -// suppress : bool, optional -// If True, always print floating point numbers using fixed point -// notation, in which case numbers equal to zero in the current precision -// will print as zero. If False, then scientific notation is used when -// absolute value of the smallest number is < 1e-4 or the ratio of the -// maximum absolute value to the minimum is > 1e3. The default is False. -// nanstr : str, optional -// String representation of floating point not-a-number (default nan). -// infstr : str, optional -// String representation of floating point infinity (default inf). -// sign : string, either '-', '+', or ' ', optional -// Controls printing of the sign of floating-point types. If '+', always -// print the sign of positive values. If ' ', always prints a space -// (whitespace character) in the sign position of positive values. If -// '-', omit the sign character of positive values. (default '-') -// formatter : dict of callables, optional -// If not None, the keys should indicate the type(s) that the respective -// formatting function applies to. Callables should return a string. -// Types that are not specified (by their corresponding keys) are handled -// by the default formatters. Individual types for which a formatter -// can be set are: -// -// - 'bool' -// - 'int' -// - 'timedelta' : a `numpy.timedelta64` -// - 'datetime' : a `numpy.datetime64` -// - 'float' -// - 'longfloat' : 128-bit floats -// - 'complexfloat' -// - 'longcomplexfloat' : composed of two 128-bit floats -// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` -// - 'object' : `np.object_` arrays -// -// Other keys that can be used to set a group of types at once are: -// -// - 'all' : sets all types -// - 'int_kind' : sets 'int' -// - 'float_kind' : sets 'float' and 'longfloat' -// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' -// - 'str_kind' : sets 'numpystr' -// floatmode : str, optional -// Controls the interpretation of the `precision` option for -// floating-point types. Can take the following values -// (default maxprec_equal): -// -// * 'fixed': Always print exactly `precision` fractional digits, -// even if this would print more or fewer digits than -// necessary to specify the value uniquely. -// * 'unique': Print the minimum number of fractional digits necessary -// to represent each value uniquely. Different elements may -// have a different number of digits. The value of the -// `precision` option is ignored. -// * 'maxprec': Print at most `precision` fractional digits, but if -// an element can be uniquely represented with fewer digits -// only print it with that many. -// * 'maxprec_equal': Print at most `precision` fractional digits, -// but if every element in the array can be uniquely -// represented with an equal number of fewer digits, use that -// many digits for all elements. -// legacy : string or `False`, optional -// If set to the string `'1.13'` enables 1.13 legacy printing mode. This -// approximates numpy 1.13 print output by including a space in the sign -// position of floats and different behavior for 0d arrays. This also -// enables 1.21 legacy printing mode (described below). -// -// If set to the string `'1.21'` enables 1.21 legacy printing mode. This -// approximates numpy 1.21 print output of complex structured dtypes -// by not inserting spaces after commas that separate fields and after -// colons. -// -// If set to `False`, disables legacy mode. -// -// Unrecognized strings will be ignored with a warning for forward -// compatibility. -// -// .. versionadded:: 1.14.0 -// .. versionchanged:: 1.22.0 -// -// See Also -// -------- -// get_printoptions, printoptions, set_string_function, array2string -// -// Notes -// ----- -// `formatter` is always reset with a call to `set_printoptions`. -// -// Use `printoptions` as a context manager to set the values temporarily. -// -// Examples -// -------- -// Floating point precision can be set: -// -// >>> np.set_printoptions(precision=4) -// >>> np.array([1.123456789]) -// [1.1235] -// -// Long arrays can be summarised: -// -// >>> np.set_printoptions(threshold=5) -// >>> np.arange(10) -// array([0, 1, 2, ..., 7, 8, 9]) -// -// Small results can be suppressed: -// -// >>> eps = np.finfo(float).eps -// >>> x = np.arange(4.) -// >>> x**2 - (x + eps)**2 -// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) -// >>> np.set_printoptions(suppress=True) -// >>> x**2 - (x + eps)**2 -// array([-0., -0., 0., 0.]) -// -// A custom formatter can be used to display array elements as desired: -// -// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) -// >>> x = np.arange(3) -// >>> x -// array([int: 0, int: -1, int: -2]) -// >>> np.set_printoptions() # formatter gets reset -// >>> x -// array([0, 1, 2]) -// -// To put back the default options, you can use: -// -// >>> np.set_printoptions(edgeitems=3, infstr='inf', -// ... linewidth=75, nanstr='nan', precision=8, -// ... suppress=False, threshold=1000, formatter=None) -// -// Also to temporarily override options, use `printoptions` as a context manager: -// -// >>> with np.printoptions(precision=2, suppress=True, threshold=5): -// ... np.linspace(0, 10, 10) -// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) -// -// -// -//go:linkname SetPrintoptions py.set_printoptions -func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object -// -// Return the current print options. -// -// Returns -// ------- -// print_opts : dict -// Dictionary of current print options with keys -// -// - precision : int -// - threshold : int -// - edgeitems : int -// - linewidth : int -// - suppress : bool -// - nanstr : str -// - infstr : str -// - formatter : dict of callables -// - sign : str -// -// For a full description of these options, see `set_printoptions`. -// -// See Also -// -------- -// set_printoptions, printoptions, set_string_function -// -// -// -//go:linkname GetPrintoptions py.get_printoptions -func GetPrintoptions() *py.Object -// Context manager for setting print options. -// -// Set print options for the scope of the `with` block, and restore the old -// options at the end. See `set_printoptions` for the full description of -// available options. -// -// Examples -// -------- -// -// >>> from numpy.testing import assert_equal -// >>> with np.printoptions(precision=2): -// ... np.array([2.0]) / 3 -// array([0.67]) -// -// The `as`-clause of the `with`-statement gives the current print options: -// -// >>> with np.printoptions(precision=2) as opts: -// ... assert_equal(opts, np.get_printoptions()) -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// -// -//go:linkname Printoptions py.printoptions -func Printoptions(__llgo_va_list ...interface{}) *py.Object -// -// Format a floating-point scalar as a decimal string in positional notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed, or if `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// fractional : boolean, optional -// If `True`, the cutoffs of `precision` and `min_digits` refer to the -// total number of digits after the decimal point, including leading -// zeros. -// If `False`, `precision` and `min_digits` refer to the total number of -// significant digits, before or after the decimal point, ignoring leading -// zeros. -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// pad_right : non-negative integer, optional -// Pad the right side of the string with whitespace until at least that -// many characters are to the right of the decimal point. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. Only has an effect if `unique=True` -// in which case additional digits past those necessary to uniquely -// identify the value may be printed, rounding the last additional digit. -// -// -- versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_scientific -// -// Examples -// -------- -// >>> np.format_float_positional(np.float32(np.pi)) -// '3.1415927' -// >>> np.format_float_positional(np.float16(np.pi)) -// '3.14' -// >>> np.format_float_positional(np.float16(0.3)) -// '0.3' -// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) -// '0.3000488281' -// -// -//go:linkname FormatFloatPositional py.format_float_positional -func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object -// -// Format a floating-point scalar as a decimal string in scientific notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed. If `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// exp_digits : non-negative integer, optional -// Pad the exponent with zeros until it contains at least this many digits. -// If omitted, the exponent will be at least 2 digits. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. This only has an effect for -// `unique=True`. In that case more digits than necessary to uniquely -// identify the value may be printed and rounded unbiased. -// -// -- versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_positional -// -// Examples -// -------- -// >>> np.format_float_scientific(np.float32(np.pi)) -// '3.1415927e+00' -// >>> s = np.float32(1.23e24) -// >>> np.format_float_scientific(s, unique=False, precision=15) -// '1.230000071797338e+24' -// >>> np.format_float_scientific(s, exp_digits=4) -// '1.23e+0024' -// -// -//go:linkname FormatFloatScientific py.format_float_scientific -func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object -// -// Return an ndarray of the provided type that satisfies requirements. -// -// This function is useful to be sure that an array with the correct flags -// is returned for passing to compiled code (perhaps through ctypes). -// -// Parameters -// ---------- -// a : array_like -// The object to be converted to a type-and-requirement-satisfying array. -// dtype : data-type -// The required data-type. If None preserve the current dtype. If your -// application requires the data to be in native byteorder, include -// a byteorder specification as a part of the dtype specification. -// requirements : str or sequence of str -// The requirements list can be any of the following -// -// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array -// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array -// * 'ALIGNED' ('A') - ensure a data-type aligned array -// * 'WRITEABLE' ('W') - ensure a writable array -// * 'OWNDATA' ('O') - ensure an array that owns its own data -// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array with specified requirements and type if given. -// -// See Also -// -------- -// asarray : Convert input to an ndarray. -// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// ndarray.flags : Information about the memory layout of the array. -// -// Notes -// ----- -// The returned array will be guaranteed to have the listed requirements -// by making a copy if needed. -// -// Examples -// -------- -// >>> x = np.arange(6).reshape(2,3) -// >>> x.flags -// C_CONTIGUOUS : True -// F_CONTIGUOUS : False -// OWNDATA : False -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False -// -// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) -// >>> y.flags -// C_CONTIGUOUS : False -// F_CONTIGUOUS : True -// OWNDATA : True -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False -// -// -// -//go:linkname Require py.require -func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object -// -// Set how floating-point errors are handled. -// -// Note that operations on integer scalar types (such as `int16`) are -// handled like floating point, and are affected by these settings. -// -// Parameters -// ---------- -// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Set treatment for all types of floating-point errors at once: -// -// - ignore: Take no action when the exception occurs. -// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). -// - raise: Raise a `FloatingPointError`. -// - call: Call a function specified using the `seterrcall` function. -// - print: Print a warning directly to ``stdout``. -// - log: Record error in a Log object specified by `seterrcall`. -// -// The default is not to change the current behavior. -// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for division by zero. -// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point overflow. -// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point underflow. -// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for invalid floating-point operation. -// -// Returns -// ------- -// old_settings : dict -// Dictionary containing the old settings. -// -// See also -// -------- -// seterrcall : Set a callback function for the 'call' mode. -// geterr, geterrcall, errstate -// -// Notes -// ----- -// The floating-point exceptions are defined in the IEEE 754 standard [1]_: -// -// - Division by zero: infinite result obtained from finite numbers. -// - Overflow: result too large to be expressed. -// - Underflow: result so close to zero that some precision -// was lost. -// - Invalid operation: result is not an expressible number, typically -// indicates that a NaN was produced. -// -// .. [1] https://en.wikipedia.org/wiki/IEEE_754 -// -// Examples -// -------- -// >>> old_settings = np.seterr(all='ignore') #seterr to known value -// >>> np.seterr(over='raise') -// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} -// >>> np.seterr(**old_settings) # reset to default -// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} -// -// >>> np.int16(32000) * np.int16(3) -// 30464 -// >>> old_settings = np.seterr(all='warn', over='raise') -// >>> np.int16(32000) * np.int16(3) -// Traceback (most recent call last): -// File "", line 1, in -// FloatingPointError: overflow encountered in scalar multiply -// -// >>> old_settings = np.seterr(all='print') -// >>> np.geterr() -// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} -// >>> np.int16(32000) * np.int16(3) -// 30464 -// -// -// -//go:linkname Seterr py.seterr -func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object -// -// Get the current way of handling floating-point errors. -// -// Returns -// ------- -// res : dict -// A dictionary with keys "divide", "over", "under", and "invalid", -// whose values are from the strings "ignore", "print", "log", "warn", -// "raise", and "call". The keys represent possible floating-point -// exceptions, and the values define how these exceptions are handled. -// -// See Also -// -------- -// geterrcall, seterr, seterrcall -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterr() -// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) -// array([nan, 1., 1.]) -// -// >>> oldsettings = np.seterr(all='warn', over='raise') -// >>> np.geterr() -// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) -// array([nan, 1., 1.]) -// -// -// -//go:linkname Geterr py.geterr -func Geterr() *py.Object -// -// Set the size of the buffer used in ufuncs. -// -// Parameters -// ---------- -// size : int -// Size of buffer. -// -// -// -//go:linkname Setbufsize py.setbufsize -func Setbufsize(size *py.Object) *py.Object -// -// Return the size of the buffer used in ufuncs. -// -// Returns -// ------- -// getbufsize : int -// Size of ufunc buffer in bytes. -// -// -// -//go:linkname Getbufsize py.getbufsize -func Getbufsize() *py.Object -// -// Set the floating-point error callback function or log object. -// -// There are two ways to capture floating-point error messages. The first -// is to set the error-handler to 'call', using `seterr`. Then, set -// the function to call using this function. -// -// The second is to set the error-handler to 'log', using `seterr`. -// Floating-point errors then trigger a call to the 'write' method of -// the provided object. -// -// Parameters -// ---------- -// func : callable f(err, flag) or object with write method -// Function to call upon floating-point errors ('call'-mode) or -// object whose 'write' method is used to log such message ('log'-mode). -// -// The call function takes two arguments. The first is a string describing -// the type of error (such as "divide by zero", "overflow", "underflow", -// or "invalid value"), and the second is the status flag. The flag is a -// byte, whose four least-significant bits indicate the type of error, one -// of "divide", "over", "under", "invalid":: -// -// [0 0 0 0 divide over under invalid] -// -// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. -// -// If an object is provided, its write method should take one argument, -// a string. -// -// Returns -// ------- -// h : callable, log instance or None -// The old error handler. -// -// See Also -// -------- -// seterr, geterr, geterrcall -// -// Examples -// -------- -// Callback upon error: -// -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// ... -// -// >>> saved_handler = np.seterrcall(err_handler) -// >>> save_err = np.seterr(all='call') -// -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> np.seterrcall(saved_handler) -// -// >>> np.seterr(**save_err) -// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} -// -// Log error message: -// -// >>> class Log: -// ... def write(self, msg): -// ... print("LOG: %s" % msg) -// ... -// -// >>> log = Log() -// >>> saved_handler = np.seterrcall(log) -// >>> save_err = np.seterr(all='log') -// -// >>> np.array([1, 2, 3]) / 0.0 -// LOG: Warning: divide by zero encountered in divide -// array([inf, inf, inf]) -// -// >>> np.seterrcall(saved_handler) -// -// >>> np.seterr(**save_err) -// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} -// -// -// -//go:linkname Seterrcall py.seterrcall -func Seterrcall(func_ *py.Object) *py.Object -// -// Return the current callback function used on floating-point errors. -// -// When the error handling for a floating-point error (one of "divide", -// "over", "under", or "invalid") is set to 'call' or 'log', the function -// that is called or the log instance that is written to is returned by -// `geterrcall`. This function or log instance has been set with -// `seterrcall`. -// -// Returns -// ------- -// errobj : callable, log instance or None -// The current error handler. If no handler was set through `seterrcall`, -// ``None`` is returned. -// -// See Also -// -------- -// seterrcall, seterr, geterr -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterrcall() # we did not yet set a handler, returns None -// -// >>> oldsettings = np.seterr(all='call') -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// >>> oldhandler = np.seterrcall(err_handler) -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> cur_handler = np.geterrcall() -// >>> cur_handler is err_handler -// True -// -// -// -//go:linkname Geterrcall py.geterrcall -func Geterrcall() *py.Object -// -// Return a description for the given data type code. -// -// Parameters -// ---------- -// char : str -// Data type code. -// -// Returns -// ------- -// out : str -// Description of the input data type code. -// -// See Also -// -------- -// dtype, typecodes -// -// Examples -// -------- -// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', -// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] -// >>> for typechar in typechars: -// ... print(typechar, ' : ', np.typename(typechar)) -// ... -// S1 : character -// ? : bool -// B : unsigned char -// D : complex double precision -// G : complex long double precision -// F : complex single precision -// I : unsigned integer -// H : unsigned short -// L : unsigned long integer -// O : object -// Q : unsigned long long integer -// S : string -// U : unicode -// V : void -// b : signed char -// d : double precision -// g : long precision -// f : single precision -// i : integer -// h : short -// l : long integer -// q : long long integer -// -// -// -//go:linkname Typename py.typename -func Typename(char *py.Object) *py.Object -// -// Return the character for the minimum-size type to which given types can -// be safely cast. -// -// The returned type character must represent the smallest size dtype such -// that an array of the returned type can handle the data from an array of -// all types in `typechars` (or if `typechars` is an array, then its -// dtype.char). -// -// Parameters -// ---------- -// typechars : list of str or array_like -// If a list of strings, each string should represent a dtype. -// If array_like, the character representation of the array dtype is used. -// typeset : str or list of str, optional -// The set of characters that the returned character is chosen from. -// The default set is 'GDFgdf'. -// default : str, optional -// The default character, this is returned if none of the characters in -// `typechars` matches a character in `typeset`. -// -// Returns -// ------- -// typechar : str -// The character representing the minimum-size type that was found. -// -// See Also -// -------- -// dtype, sctype2char, maximum_sctype -// -// Examples -// -------- -// >>> np.mintypecode(['d', 'f', 'S']) -// 'd' -// >>> x = np.array([1.1, 2-3.j]) -// >>> np.mintypecode(x) -// 'D' -// -// >>> np.mintypecode('abceh', default='G') -// 'G' -// -// -// -//go:linkname Mintypecode py.mintypecode -func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *py.Object) *py.Object -// -// Return the indices to access the main diagonal of an array. -// -// This returns a tuple of indices that can be used to access the main -// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape -// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for -// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` -// for ``i = [0..n-1]``. -// -// Parameters -// ---------- -// n : int -// The size, along each dimension, of the arrays for which the returned -// indices can be used. -// -// ndim : int, optional -// The number of dimensions. -// -// See Also -// -------- -// diag_indices_from -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Create a set of indices to access the diagonal of a (4, 4) array: -// -// >>> di = np.diag_indices(4) -// >>> di -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// >>> a[di] = 100 -// >>> a -// array([[100, 1, 2, 3], -// [ 4, 100, 6, 7], -// [ 8, 9, 100, 11], -// [ 12, 13, 14, 100]]) -// -// Now, we create indices to manipulate a 3-D array: -// -// >>> d3 = np.diag_indices(2, 3) -// >>> d3 -// (array([0, 1]), array([0, 1]), array([0, 1])) -// -// And use it to set the diagonal of an array of zeros to 1: -// -// >>> a = np.zeros((2, 2, 2), dtype=int) -// >>> a[d3] = 1 -// >>> a -// array([[[1, 0], -// [0, 0]], -// [[0, 0], -// [0, 1]]]) -// -// -// -//go:linkname DiagIndices py.diag_indices -func DiagIndices(n *py.Object, ndim *py.Object) *py.Object -// -// Check whether or not an object can be iterated over. -// -// Parameters -// ---------- -// y : object -// Input object. -// -// Returns -// ------- -// b : bool -// Return ``True`` if the object has an iterator method or is a -// sequence and ``False`` otherwise. -// -// -// Examples -// -------- -// >>> np.iterable([1, 2, 3]) -// True -// >>> np.iterable(2) -// False -// -// Notes -// ----- -// In most cases, the results of ``np.iterable(obj)`` are consistent with -// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is -// the treatment of 0-dimensional arrays:: -// -// >>> from collections.abc import Iterable -// >>> a = np.array(1.0) # 0-dimensional numpy array -// >>> isinstance(a, Iterable) -// True -// >>> np.iterable(a) -// False -// -// -// -//go:linkname Iterable py.iterable -func Iterable(y *py.Object) *py.Object -// -// Display a message on a device. -// -// Parameters -// ---------- -// mesg : str -// Message to display. -// device : object -// Device to write message. If None, defaults to ``sys.stdout`` which is -// very similar to ``print``. `device` needs to have ``write()`` and -// ``flush()`` methods. -// linefeed : bool, optional -// Option whether to print a line feed or not. Defaults to True. -// -// Raises -// ------ -// AttributeError -// If `device` does not have a ``write()`` or ``flush()`` method. -// -// Examples -// -------- -// Besides ``sys.stdout``, a file-like object can also be used as it has -// both required methods: -// -// >>> from io import StringIO -// >>> buf = StringIO() -// >>> np.disp(u'"Display" in a file', device=buf) -// >>> buf.getvalue() -// '"Display" in a file\n' -// -// -// -//go:linkname Disp py.disp -func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object -// Convert the input to an array, checking for NaNs or Infs. -// -// Parameters -// ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes lists, lists of tuples, tuples, tuples of tuples, tuples -// of lists and ndarrays. Success requires no NaNs or Infs. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'C'. -// -// Returns -// ------- -// out : ndarray -// Array interpretation of `a`. No copy is performed if the input -// is already an ndarray. If `a` is a subclass of ndarray, a base -// class ndarray is returned. -// -// Raises -// ------ -// ValueError -// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). -// -// See Also -// -------- -// asarray : Create and array. -// asanyarray : Similar function which passes through subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfarray : Convert input to a floating point ndarray. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. -// -// Examples -// -------- -// Convert a list into an array. If all elements are finite -// ``asarray_chkfinite`` is identical to ``asarray``. -// -// >>> a = [1, 2] -// >>> np.asarray_chkfinite(a, dtype=float) -// array([1., 2.]) -// -// Raises ValueError if array_like contains Nans or Infs. -// -// >>> a = [1, 2, np.inf] -// >>> try: -// ... np.asarray_chkfinite(a) -// ... except ValueError: -// ... print('ValueError') -// ... -// ValueError -// -// -// -//go:linkname AsarrayChkfinite py.asarray_chkfinite -func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Return the Hamming window. -// -// The Hamming window is a taper formed by using a weighted cosine. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, blackman, hanning, kaiser -// -// Notes -// ----- -// The Hamming window is defined as -// -// .. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right) -// \qquad 0 \leq n \leq M-1 -// -// The Hamming was named for R. W. Hamming, an associate of J. W. Tukey -// and is described in Blackman and Tukey. It was recommended for -// smoothing the truncated autocovariance function in the time domain. -// Most references to the Hamming window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 109-110. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> np.hamming(12) -// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary -// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, -// 0.15302337, 0.08 ]) -// -// Plot the window and the frequency response: -// -// >>> import matplotlib.pyplot as plt -// >>> from numpy.fft import fft, fftshift -// >>> window = np.hamming(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Hamming window") -// Text(0.5, 1.0, 'Hamming window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> response = 20 * np.log10(mag) -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Hamming window") -// Text(0.5, 1.0, 'Frequency response of Hamming window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// ... -// >>> plt.show() -// -// -// -//go:linkname Hamming py.hamming -func Hamming(M *py.Object) *py.Object -// -// Return the Hanning window. -// -// The Hanning window is a taper formed by using a weighted cosine. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray, shape(M,) -// The window, with the maximum value normalized to one (the value -// one appears only if `M` is odd). -// -// See Also -// -------- -// bartlett, blackman, hamming, kaiser -// -// Notes -// ----- -// The Hanning window is defined as -// -// .. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right) -// \qquad 0 \leq n \leq M-1 -// -// The Hanning was named for Julius von Hann, an Austrian meteorologist. -// It is also known as the Cosine Bell. Some authors prefer that it be -// called a Hann window, to help avoid confusion with the very similar -// Hamming window. -// -// Most references to the Hanning window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 106-108. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> np.hanning(12) -// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, -// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, -// 0.07937323, 0. ]) -// -// Plot the window and its frequency response: -// -// >>> import matplotlib.pyplot as plt -// >>> from numpy.fft import fft, fftshift -// >>> window = np.hanning(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Hann window") -// Text(0.5, 1.0, 'Hann window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of the Hann window") -// Text(0.5, 1.0, 'Frequency response of the Hann window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// ... -// >>> plt.show() -// -// -// -//go:linkname Hanning py.hanning -func Hanning(M *py.Object) *py.Object -// -// Return the Bartlett window. -// -// The Bartlett window is very similar to a triangular window, except -// that the end points are at zero. It is often used in signal -// processing for tapering a signal, without generating too much -// ripple in the frequency domain. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : array -// The triangular window, with the maximum value normalized to one -// (the value one appears only if the number of samples is odd), with -// the first and last samples equal to zero. -// -// See Also -// -------- -// blackman, hamming, hanning, kaiser -// -// Notes -// ----- -// The Bartlett window is defined as -// -// .. math:: w(n) = \frac{2}{M-1} \left( -// \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| -// \right) -// -// Most references to the Bartlett window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. Note that convolution with this window produces linear -// interpolation. It is also known as an apodization (which means "removing -// the foot", i.e. smoothing discontinuities at the beginning and end of the -// sampled signal) or tapering function. The Fourier transform of the -// Bartlett window is the product of two sinc functions. Note the excellent -// discussion in Kanasewich [2]_. -// -// References -// ---------- -// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", -// Biometrika 37, 1-16, 1950. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 109-110. -// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal -// Processing", Prentice-Hall, 1999, pp. 468-471. -// .. [4] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 429. -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.bartlett(12) -// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary -// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, -// 0.18181818, 0. ]) -// -// Plot the window and its frequency response (requires SciPy and matplotlib): -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.bartlett(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Bartlett window") -// Text(0.5, 1.0, 'Bartlett window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Bartlett window") -// Text(0.5, 1.0, 'Frequency response of Bartlett window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> _ = plt.axis('tight') -// >>> plt.show() -// -// -// -//go:linkname Bartlett py.bartlett -func Bartlett(M *py.Object) *py.Object -// -// Return the Blackman window. -// -// The Blackman window is a taper formed by using the first three -// terms of a summation of cosines. It was designed to have close to the -// minimal leakage possible. It is close to optimal, only slightly worse -// than a Kaiser window. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an empty -// array is returned. -// -// Returns -// ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value one -// appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, hamming, hanning, kaiser -// -// Notes -// ----- -// The Blackman window is defined as -// -// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) -// -// Most references to the Blackman window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. It is known as a -// "near optimal" tapering function, almost as good (by some measures) -// as the kaiser window. -// -// References -// ---------- -// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, -// Dover Publications, New York. -// -// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. -// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.blackman(12) -// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary -// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, -// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, -// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) -// -// Plot the window and the frequency response: -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.blackman(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Blackman window") -// Text(0.5, 1.0, 'Blackman window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Blackman window") -// Text(0.5, 1.0, 'Frequency response of Blackman window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> _ = plt.axis('tight') -// >>> plt.show() -// -// -// -//go:linkname Blackman py.blackman -func Blackman(M *py.Object) *py.Object -// -// Return the Kaiser window. -// -// The Kaiser window is a taper formed by using a Bessel function. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// beta : float -// Shape parameter for window. -// -// Returns -// ------- -// out : array -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, blackman, hamming, hanning -// -// Notes -// ----- -// The Kaiser window is defined as -// -// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} -// \right)/I_0(\beta) -// -// with -// -// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, -// -// where :math:`I_0` is the modified zeroth-order Bessel function. -// -// The Kaiser was named for Jim Kaiser, who discovered a simple -// approximation to the DPSS window based on Bessel functions. The Kaiser -// window is a very good approximation to the Digital Prolate Spheroidal -// Sequence, or Slepian window, which is the transform which maximizes the -// energy in the main lobe of the window relative to total energy. -// -// The Kaiser can approximate many other windows by varying the beta -// parameter. -// -// ==== ======================= -// beta Window shape -// ==== ======================= -// 0 Rectangular -// 5 Similar to a Hamming -// 6 Similar to a Hanning -// 8.6 Similar to a Blackman -// ==== ======================= -// -// A beta value of 14 is probably a good starting point. Note that as beta -// gets large, the window narrows, and so the number of samples needs to be -// large enough to sample the increasingly narrow spike, otherwise NaNs will -// get returned. -// -// Most references to the Kaiser window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by -// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. -// John Wiley and Sons, New York, (1966). -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 177-178. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.kaiser(12, 14) -// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary -// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, -// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, -// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) -// -// -// Plot the window and the frequency response: -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.kaiser(51, 14) -// >>> plt.plot(window) -// [] -// >>> plt.title("Kaiser window") -// Text(0.5, 1.0, 'Kaiser window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> response = 20 * np.log10(mag) -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Kaiser window") -// Text(0.5, 1.0, 'Frequency response of Kaiser window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// (-0.5, 0.5, -100.0, ...) # may vary -// >>> plt.show() -// -// -// -//go:linkname Kaiser py.kaiser -func Kaiser(M *py.Object, beta *py.Object) *py.Object -// -// Add documentation to an existing object, typically one defined in C -// -// The purpose is to allow easier editing of the docstrings without requiring -// a re-compile. This exists primarily for internal use within numpy itself. -// -// Parameters -// ---------- -// place : str -// The absolute name of the module to import from -// obj : str -// The name of the object to add documentation to, typically a class or -// function name -// doc : {str, Tuple[str, str], List[Tuple[str, str]]} -// If a string, the documentation to apply to `obj` -// -// If a tuple, then the first element is interpreted as an attribute of -// `obj` and the second as the docstring to apply - ``(method, docstring)`` -// -// If a list, then each element of the list should be a tuple of length -// two - ``[(method1, docstring1), (method2, docstring2), ...]`` -// warn_on_python : bool -// If True, the default, emit `UserWarning` if this is used to attach -// documentation to a pure-python object. -// -// Notes -// ----- -// This routine never raises an error if the docstring can't be written, but -// will raise an error if the object being documented does not exist. -// -// This routine cannot modify read-only docstrings, as appear -// in new-style classes or built-in functions. Because this -// routine never raises an error the caller must check manually -// that the docstrings were changed. -// -// Since this function grabs the ``char *`` from a c-level str object and puts -// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of -// C-API best-practices, by: -// -// - modifying a `PyTypeObject` after calling `PyType_Ready` -// - calling `Py_INCREF` on the str and losing the reference, so the str -// will never be released -// -// If possible it should be avoided. -// -// -//go:linkname AddNewdoc py.add_newdoc -func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object -// Find the wrapper for the array with the highest priority. -// -// In case of ties, leftmost wins. If no wrapper is found, return None -// -// -//go:linkname GetArrayWrap py.get_array_wrap -func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object -// -// Broadcast the input shapes into a single shape. -// -// :ref:`Learn more about broadcasting here `. -// -// .. versionadded:: 1.20.0 -// -// Parameters -// ---------- -// `*args` : tuples of ints, or ints -// The shapes to be broadcast against each other. -// -// Returns -// ------- -// tuple -// Broadcasted shape. -// -// Raises -// ------ -// ValueError -// If the shapes are not compatible and cannot be broadcast according -// to NumPy's broadcasting rules. -// -// See Also -// -------- -// broadcast -// broadcast_arrays -// broadcast_to -// -// Examples -// -------- -// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) -// (3, 2) -// -// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) -// (5, 6, 7) -// -// -//go:linkname BroadcastShapes py.broadcast_shapes -func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object -// -// Return a 2-D array with ones on the diagonal and zeros elsewhere. -// -// Parameters -// ---------- -// N : int -// Number of rows in the output. -// M : int, optional -// Number of columns in the output. If None, defaults to `N`. -// k : int, optional -// Index of the diagonal: 0 (the default) refers to the main diagonal, -// a positive value refers to an upper diagonal, and a negative value -// to a lower diagonal. -// dtype : data-type, optional -// Data-type of the returned array. -// order : {'C', 'F'}, optional -// Whether the output should be stored in row-major (C-style) or -// column-major (Fortran-style) order in memory. -// -// .. versionadded:: 1.14.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// I : ndarray of shape (N,M) -// An array where all elements are equal to zero, except for the `k`-th -// diagonal, whose values are equal to one. -// -// See Also -// -------- -// identity : (almost) equivalent function -// diag : diagonal 2-D array from a 1-D array specified by the user. -// -// Examples -// -------- -// >>> np.eye(2, dtype=int) -// array([[1, 0], -// [0, 1]]) -// >>> np.eye(3, k=1) -// array([[0., 1., 0.], -// [0., 0., 1.], -// [0., 0., 0.]]) -// -// -// -//go:linkname Eye py.eye -func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// An array with ones at and below the given diagonal and zeros elsewhere. -// -// Parameters -// ---------- -// N : int -// Number of rows in the array. -// M : int, optional -// Number of columns in the array. -// By default, `M` is taken equal to `N`. -// k : int, optional -// The sub-diagonal at and below which the array is filled. -// `k` = 0 is the main diagonal, while `k` < 0 is below it, -// and `k` > 0 is above. The default is 0. -// dtype : dtype, optional -// Data type of the returned array. The default is float. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// tri : ndarray of shape (N, M) -// Array with its lower triangle filled with ones and zero elsewhere; -// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. -// -// Examples -// -------- -// >>> np.tri(3, 5, 2, dtype=int) -// array([[1, 1, 1, 0, 0], -// [1, 1, 1, 1, 0], -// [1, 1, 1, 1, 1]]) -// -// >>> np.tri(3, 5, -1) -// array([[0., 0., 0., 0., 0.], -// [1., 0., 0., 0., 0.], -// [1., 1., 0., 0., 0.]]) -// -// -// -//go:linkname Tri py.tri -func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object -// -// Return the indices to access (n, n) arrays, given a masking function. -// -// Assume `mask_func` is a function that, for a square array a of size -// ``(n, n)`` with a possible offset argument `k`, when called as -// ``mask_func(a, k)`` returns a new array with zeros in certain locations -// (functions like `triu` or `tril` do precisely this). Then this function -// returns the indices where the non-zero values would be located. -// -// Parameters -// ---------- -// n : int -// The returned indices will be valid to access arrays of shape (n, n). -// mask_func : callable -// A function whose call signature is similar to that of `triu`, `tril`. -// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. -// `k` is an optional argument to the function. -// k : scalar -// An optional argument which is passed through to `mask_func`. Functions -// like `triu`, `tril` take a second argument that is interpreted as an -// offset. -// -// Returns -// ------- -// indices : tuple of arrays. -// The `n` arrays of indices corresponding to the locations where -// ``mask_func(np.ones((n, n)), k)`` is True. -// -// See Also -// -------- -// triu, tril, triu_indices, tril_indices -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// These are the indices that would allow you to access the upper triangular -// part of any 3x3 array: -// -// >>> iu = np.mask_indices(3, np.triu) -// -// For example, if `a` is a 3x3 array: -// -// >>> a = np.arange(9).reshape(3, 3) -// >>> a -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) -// >>> a[iu] -// array([0, 1, 2, 4, 5, 8]) -// -// An offset can be passed also to the masking function. This gets us the -// indices starting on the first diagonal right of the main one: -// -// >>> iu1 = np.mask_indices(3, np.triu, 1) -// -// with which we now extract only three elements: -// -// >>> a[iu1] -// array([1, 2, 5]) -// -// -// -//go:linkname MaskIndices py.mask_indices -func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object -// -// Return the indices for the lower-triangle of an (n, m) array. -// -// Parameters -// ---------- -// n : int -// The row dimension of the arrays for which the returned -// indices will be valid. -// k : int, optional -// Diagonal offset (see `tril` for details). -// m : int, optional -// .. versionadded:: 1.9.0 -// -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. -// -// -// Returns -// ------- -// inds : tuple of arrays -// The indices for the triangle. The returned tuple contains two arrays, -// each with the indices along one dimension of the array. -// -// See also -// -------- -// triu_indices : similar function, for upper-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// tril, triu -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Compute two different sets of indices to access 4x4 arrays, one for the -// lower triangular part starting at the main diagonal, and one starting two -// diagonals further right: -// -// >>> il1 = np.tril_indices(4) -// >>> il2 = np.tril_indices(4, 2) -// -// Here is how they can be used with a sample array: -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Both for indexing: -// -// >>> a[il1] -// array([ 0, 4, 5, ..., 13, 14, 15]) -// -// And for assigning values: -// -// >>> a[il1] = -1 -// >>> a -// array([[-1, 1, 2, 3], -// [-1, -1, 6, 7], -// [-1, -1, -1, 11], -// [-1, -1, -1, -1]]) -// -// These cover almost the whole array (two diagonals right of the main one): -// -// >>> a[il2] = -10 -// >>> a -// array([[-10, -10, -10, 3], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10]]) -// -// -// -//go:linkname TrilIndices py.tril_indices -func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object -// -// Return the indices for the upper-triangle of an (n, m) array. -// -// Parameters -// ---------- -// n : int -// The size of the arrays for which the returned indices will -// be valid. -// k : int, optional -// Diagonal offset (see `triu` for details). -// m : int, optional -// .. versionadded:: 1.9.0 -// -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. -// -// -// Returns -// ------- -// inds : tuple, shape(2) of ndarrays, shape(`n`) -// The indices for the triangle. The returned tuple contains two arrays, -// each with the indices along one dimension of the array. Can be used -// to slice a ndarray of shape(`n`, `n`). -// -// See also -// -------- -// tril_indices : similar function, for lower-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// triu, tril -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Compute two different sets of indices to access 4x4 arrays, one for the -// upper triangular part starting at the main diagonal, and one starting two -// diagonals further right: -// -// >>> iu1 = np.triu_indices(4) -// >>> iu2 = np.triu_indices(4, 2) -// -// Here is how they can be used with a sample array: -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Both for indexing: -// -// >>> a[iu1] -// array([ 0, 1, 2, ..., 10, 11, 15]) -// -// And for assigning values: -// -// >>> a[iu1] = -1 -// >>> a -// array([[-1, -1, -1, -1], -// [ 4, -1, -1, -1], -// [ 8, 9, -1, -1], -// [12, 13, 14, -1]]) -// -// These cover only a small part of the whole array (two diagonals right -// of the main one): -// -// >>> a[iu2] = -10 -// >>> a -// array([[ -1, -1, -10, -10], -// [ 4, -1, -1, -10], -// [ 8, 9, -1, -1], -// [ 12, 13, 14, -1]]) -// -// -// -//go:linkname TriuIndices py.triu_indices -func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object -// -// Determine if a class is a subclass of a second class. -// -// `issubclass_` is equivalent to the Python built-in ``issubclass``, -// except that it returns False instead of raising a TypeError if one -// of the arguments is not a class. -// -// Parameters -// ---------- -// arg1 : class -// Input class. True is returned if `arg1` is a subclass of `arg2`. -// arg2 : class or tuple of classes. -// Input class. If a tuple of classes, True is returned if `arg1` is a -// subclass of any of the tuple elements. -// -// Returns -// ------- -// out : bool -// Whether `arg1` is a subclass of `arg2` or not. -// -// See Also -// -------- -// issubsctype, issubdtype, issctype -// -// Examples -// -------- -// >>> np.issubclass_(np.int32, int) -// False -// >>> np.issubclass_(np.int32, float) -// False -// >>> np.issubclass_(np.float64, float) -// True -// -// -// -//go:linkname Issubclass py.issubclass_ -func Issubclass(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Determine if the first argument is a subclass of the second argument. -// -// Parameters -// ---------- -// arg1, arg2 : dtype or dtype specifier -// Data-types. -// -// Returns -// ------- -// out : bool -// The result. -// -// See Also -// -------- -// issctype, issubdtype, obj2sctype -// -// Examples -// -------- -// >>> np.issubsctype('S8', str) -// False -// >>> np.issubsctype(np.array([1]), int) -// True -// >>> np.issubsctype(np.array([1]), float) -// False -// -// -// -//go:linkname Issubsctype py.issubsctype -func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Issues a DeprecationWarning, adds warning to `old_name`'s -// docstring, rebinds ``old_name.__name__`` and returns the new -// function object. -// -// This function may also be used as a decorator. -// -// Parameters -// ---------- -// func : function -// The function to be deprecated. -// old_name : str, optional -// The name of the function to be deprecated. Default is None, in -// which case the name of `func` is used. -// new_name : str, optional -// The new name for the function. Default is None, in which case the -// deprecation message is that `old_name` is deprecated. If given, the -// deprecation message is that `old_name` is deprecated and `new_name` -// should be used instead. -// message : str, optional -// Additional explanation of the deprecation. Displayed in the -// docstring after the warning. -// -// Returns -// ------- -// old_func : function -// The deprecated function. -// -// Examples -// -------- -// Note that ``olduint`` returns a value after printing Deprecation -// Warning: -// -// >>> olduint = np.deprecate(np.uint) -// DeprecationWarning: `uint64` is deprecated! # may vary -// >>> olduint(6) -// 6 -// -// -// -//go:linkname Deprecate py.deprecate -func Deprecate(__llgo_va_list ...interface{}) *py.Object -// -// Deprecates a function and includes the deprecation in its docstring. -// -// This function is used as a decorator. It returns an object that can be -// used to issue a DeprecationWarning, by passing the to-be decorated -// function as argument, this adds warning to the to-be decorated function's -// docstring and returns the new function object. -// -// See Also -// -------- -// deprecate : Decorate a function such that it issues a `DeprecationWarning` -// -// Parameters -// ---------- -// msg : str -// Additional explanation of the deprecation. Displayed in the -// docstring after the warning. -// -// Returns -// ------- -// obj : object -// -// -// -//go:linkname DeprecateWithDoc py.deprecate_with_doc -func DeprecateWithDoc(msg *py.Object) *py.Object -// -// Return the directory that contains the NumPy \*.h header files. -// -// Extension modules that need to compile against NumPy should use this -// function to locate the appropriate include directory. -// -// Notes -// ----- -// When using ``distutils``, for example in ``setup.py``:: -// -// import numpy as np -// ... -// Extension('extension_name', ... -// include_dirs=[np.get_include()]) -// ... -// -// -// -//go:linkname GetInclude py.get_include -func GetInclude() *py.Object -// -// Get help information for an array, function, class, or module. -// -// Parameters -// ---------- -// object : object or str, optional -// Input object or name to get information about. If `object` is -// an `ndarray` instance, information about the array is printed. -// If `object` is a numpy object, its docstring is given. If it is -// a string, available modules are searched for matching objects. -// If None, information about `info` itself is returned. -// maxwidth : int, optional -// Printing width. -// output : file like object, optional -// File like object that the output is written to, default is -// ``None``, in which case ``sys.stdout`` will be used. -// The object has to be opened in 'w' or 'a' mode. -// toplevel : str, optional -// Start search at this level. -// -// See Also -// -------- -// source, lookfor -// -// Notes -// ----- -// When used interactively with an object, ``np.info(obj)`` is equivalent -// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython -// prompt. -// -// Examples -// -------- -// >>> np.info(np.polyval) # doctest: +SKIP -// polyval(p, x) -// Evaluate the polynomial p at x. -// ... -// -// When using a string for `object` it is possible to get multiple results. -// -// >>> np.info('fft') # doctest: +SKIP -// *** Found in numpy *** -// Core FFT routines -// ... -// *** Found in numpy.fft *** -// fft(a, n=None, axis=-1) -// ... -// *** Repeat reference found in numpy.fft.fftpack *** -// *** Total of 3 references found. *** -// -// When the argument is an array, information about the array is printed. -// -// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) -// >>> np.info(a) -// class: ndarray -// shape: (2, 3) -// strides: (24, 8) -// itemsize: 8 -// aligned: True -// contiguous: True -// fortran: False -// data pointer: 0x562b6e0d2860 # may vary -// byteorder: little -// byteswap: False -// type: complex64 -// -// -// -//go:linkname Info py.info -func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object -// -// Print or write to a file the source code for a NumPy object. -// -// The source code is only returned for objects written in Python. Many -// functions and classes are defined in C and will therefore not return -// useful information. -// -// Parameters -// ---------- -// object : numpy object -// Input object. This can be any object (function, class, module, -// ...). -// output : file object, optional -// If `output` not supplied then source code is printed to screen -// (sys.stdout). File object must be created with either write 'w' or -// append 'a' modes. -// -// See Also -// -------- -// lookfor, info -// -// Examples -// -------- -// >>> np.source(np.interp) #doctest: +SKIP -// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py -// def interp(x, xp, fp, left=None, right=None): -// """.... (full docstring printed)""" -// if isinstance(x, (float, int, number)): -// return compiled_interp([x], xp, fp, left, right).item() -// else: -// return compiled_interp(x, xp, fp, left, right) -// -// The source code is only returned for objects written in Python. -// -// >>> np.source(np.array) #doctest: +SKIP -// Not available for this object. -// -// -// -//go:linkname Source py.source -func Source(object *py.Object, output *py.Object) *py.Object -// -// Print the NumPy arrays in the given dictionary. -// -// If there is no dictionary passed in or `vardict` is None then returns -// NumPy arrays in the globals() dictionary (all NumPy arrays in the -// namespace). -// -// Parameters -// ---------- -// vardict : dict, optional -// A dictionary possibly containing ndarrays. Default is globals(). -// -// Returns -// ------- -// out : None -// Returns 'None'. -// -// Notes -// ----- -// Prints out the name, shape, bytes and type of all of the ndarrays -// present in `vardict`. -// -// Examples -// -------- -// >>> a = np.arange(10) -// >>> b = np.ones(20) -// >>> np.who() -// Name Shape Bytes Type -// =========================================================== -// a 10 80 int64 -// b 20 160 float64 -// Upper bound on total bytes = 240 -// -// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', -// ... 'idx':5} -// >>> np.who(d) -// Name Shape Bytes Type -// =========================================================== -// x 2 16 float64 -// y 3 24 float64 -// Upper bound on total bytes = 40 -// -// -// -//go:linkname Who py.who -func Who(vardict *py.Object) *py.Object -// -// Do a keyword search on docstrings. -// -// A list of objects that matched the search is displayed, -// sorted by relevance. All given keywords need to be found in the -// docstring for it to be returned as a result, but the order does -// not matter. -// -// Parameters -// ---------- -// what : str -// String containing words to look for. -// module : str or list, optional -// Name of module(s) whose docstrings to go through. -// import_modules : bool, optional -// Whether to import sub-modules in packages. Default is True. -// regenerate : bool, optional -// Whether to re-generate the docstring cache. Default is False. -// output : file-like, optional -// File-like object to write the output to. If omitted, use a pager. -// -// See Also -// -------- -// source, info -// -// Notes -// ----- -// Relevance is determined only roughly, by checking if the keywords occur -// in the function name, at the start of a docstring, etc. -// -// Examples -// -------- -// >>> np.lookfor('binary representation') # doctest: +SKIP -// Search results for 'binary representation' -// ------------------------------------------ -// numpy.binary_repr -// Return the binary representation of the input number as a string. -// numpy.core.setup_common.long_double_representation -// Given a binary dump as given by GNU od -b, look for long double -// numpy.base_repr -// Return a string representation of a number in the given base system. -// ... -// -// -// -//go:linkname Lookfor py.lookfor -func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object -// -// Returns pointers to the end-points of an array. -// -// Parameters -// ---------- -// a : ndarray -// Input array. It must conform to the Python-side of the array -// interface. -// -// Returns -// ------- -// (low, high) : tuple of 2 integers -// The first integer is the first byte of the array, the second -// integer is just past the last byte of the array. If `a` is not -// contiguous it will not use every byte between the (`low`, `high`) -// values. -// -// Examples -// -------- -// >>> I = np.eye(2, dtype='f'); I.dtype -// dtype('float32') -// >>> low, high = np.byte_bounds(I) -// >>> high - low == I.size*I.itemsize -// True -// >>> I = np.eye(2); I.dtype -// dtype('float64') -// >>> low, high = np.byte_bounds(I) -// >>> high - low == I.size*I.itemsize -// True -// -// -// -//go:linkname ByteBounds py.byte_bounds -func ByteBounds(a *py.Object) *py.Object -// -// Protected string evaluation. -// -// Evaluate a string containing a Python literal expression without -// allowing the execution of arbitrary non-literal code. -// -// .. warning:: -// -// This function is identical to :py:meth:`ast.literal_eval` and -// has the same security implications. It may not always be safe -// to evaluate large input strings. -// -// Parameters -// ---------- -// source : str -// The string to evaluate. -// -// Returns -// ------- -// obj : object -// The result of evaluating `source`. -// -// Raises -// ------ -// SyntaxError -// If the code has invalid Python syntax, or if it contains -// non-literal code. -// -// Examples -// -------- -// >>> np.safe_eval('1') -// 1 -// >>> np.safe_eval('[1, 2, 3]') -// [1, 2, 3] -// >>> np.safe_eval('{"foo": ("bar", 10.0)}') -// {'foo': ('bar', 10.0)} -// -// >>> np.safe_eval('import os') -// Traceback (most recent call last): -// ... -// SyntaxError: invalid syntax -// -// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') -// Traceback (most recent call last): -// ... -// ValueError: malformed node or string: <_ast.Call object at 0x...> -// -// -// -//go:linkname SafeEval py.safe_eval -func SafeEval(source *py.Object) *py.Object -// -// Print information about various resources in the system -// including available intrinsic support and BLAS/LAPACK library -// in use -// -// .. versionadded:: 1.24.0 -// -// See Also -// -------- -// show_config : Show libraries in the system on which NumPy was built. -// -// Notes -// ----- -// 1. Information is derived with the help of `threadpoolctl `_ -// library if available. -// 2. SIMD related information is derived from ``__cpu_features__``, -// ``__cpu_baseline__`` and ``__cpu_dispatch__`` -// -// -// -//go:linkname ShowRuntime py.show_runtime -func ShowRuntime() *py.Object -// -// Load data from a text file. -// -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : data-type, optional -// Data-type of the resulting array; default: float. If this is a -// structured data-type, the resulting array will be 1-dimensional, and -// each row will be interpreted as an element of the array. In this -// case, the number of columns used must match the number of fields in -// the data-type. -// comments : str or sequence of str or None, optional -// The characters or list of characters used to indicate the start of a -// comment. None implies no comments. For backwards compatibility, byte -// strings will be decoded as 'latin1'. The default is '#'. -// delimiter : str, optional -// The character used to separate the values. For backwards compatibility, -// byte strings will be decoded as 'latin1'. The default is whitespace. -// -// .. versionchanged:: 1.23.0 -// Only single character delimiters are supported. Newline characters -// cannot be used as the delimiter. -// -// converters : dict or callable, optional -// Converter functions to customize value parsing. If `converters` is -// callable, the function is applied to all columns, else it must be a -// dict that maps column number to a parser function. -// See examples for further details. -// Default: None. -// -// .. versionchanged:: 1.23.0 -// The ability to pass a single callable to be applied to all columns -// was added. -// -// skiprows : int, optional -// Skip the first `skiprows` lines, including comments; default: 0. -// usecols : int or sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. -// The default, None, results in all columns being read. -// -// .. versionchanged:: 1.11.0 -// When a single column has to be read it is possible to use -// an integer instead of a tuple. E.g ``usecols = 3`` reads the -// fourth column the same way as ``usecols = (3,)`` would. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = loadtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// ndmin : int, optional -// The returned array will have at least `ndmin` dimensions. -// Otherwise mono-dimensional axes will be squeezed. -// Legal values: 0 (default), 1 or 2. -// -// .. versionadded:: 1.6.0 -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply to input streams. -// The special value 'bytes' enables backward compatibility workarounds -// that ensures you receive byte arrays as results if possible and passes -// 'latin1' encoded strings to converters. Override this value to receive -// unicode arrays and pass strings as input to converters. If set to None -// the system default is used. The default value is 'bytes'. -// -// .. versionadded:: 1.14.0 -// max_rows : int, optional -// Read `max_rows` rows of content after `skiprows` lines. The default is -// to read all the rows. Note that empty rows containing no data such as -// empty lines and comment lines are not counted towards `max_rows`, -// while such lines are counted in `skiprows`. -// -// .. versionadded:: 1.16.0 -// -// .. versionchanged:: 1.23.0 -// Lines containing no data, including comment lines (e.g., lines -// starting with '#' or as specified via `comments`) are not counted -// towards `max_rows`. -// quotechar : unicode character or None, optional -// The character used to denote the start and end of a quoted item. -// Occurrences of the delimiter or comment characters are ignored within -// a quoted item. The default value is ``quotechar=None``, which means -// quoting support is disabled. -// -// If two consecutive instances of `quotechar` are found within a quoted -// field, the first is treated as an escape character. See examples. -// -// .. versionadded:: 1.23.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Data read from the text file. -// -// See Also -// -------- -// load, fromstring, fromregex -// genfromtxt : Load data with missing values handled as specified. -// scipy.io.loadmat : reads MATLAB data files -// -// Notes -// ----- -// This function aims to be a fast reader for simply formatted files. The -// `genfromtxt` function provides more sophisticated handling of, e.g., -// lines with missing values. -// -// Each row in the input text file must have the same number of values to be -// able to read all values. If all rows do not have same number of values, a -// subset of up to n columns (where n is the least number of values present -// in all rows) can be read by specifying the columns via `usecols`. -// -// .. versionadded:: 1.10.0 -// -// The strings produced by the Python float.hex method can be used as -// input for floats. -// -// Examples -// -------- -// >>> from io import StringIO # StringIO behaves like a file object -// >>> c = StringIO("0 1\n2 3") -// >>> np.loadtxt(c) -// array([[0., 1.], -// [2., 3.]]) -// -// >>> d = StringIO("M 21 72\nF 35 58") -// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), -// ... 'formats': ('S1', 'i4', 'f4')}) -// array([(b'M', 21, 72.), (b'F', 35, 58.)], -// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") -// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) -// >>> x -// array([1., 3.]) -// >>> y -// array([2., 4.]) -// -// The `converters` argument is used to specify functions to preprocess the -// text prior to parsing. `converters` can be a dictionary that maps -// preprocessing functions to each column: -// -// >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n") -// >>> conv = { -// ... 0: lambda x: np.floor(float(x)), # conversion fn for column 0 -// ... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1 -// ... } -// >>> np.loadtxt(s, delimiter=",", converters=conv) -// array([[1., 3.], -// [3., 5.]]) -// -// `converters` can be a callable instead of a dictionary, in which case it -// is applied to all columns: -// -// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") -// >>> import functools -// >>> conv = functools.partial(int, base=16) -// >>> np.loadtxt(s, converters=conv) -// array([[222., 173.], -// [192., 222.]]) -// -// This example shows how `converters` can be used to convert a field -// with a trailing minus sign into a negative number. -// -// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') -// >>> def conv(fld): -// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) -// ... -// >>> np.loadtxt(s, converters=conv) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) -// -// Using a callable as the converter can be particularly useful for handling -// values with different formatting, e.g. floats with underscores: -// -// >>> s = StringIO("1 2.7 100_000") -// >>> np.loadtxt(s, converters=float) -// array([1.e+00, 2.7e+00, 1.e+05]) -// -// This idea can be extended to automatically handle values specified in -// many different formats: -// -// >>> def conv(val): -// ... try: -// ... return float(val) -// ... except ValueError: -// ... return float.fromhex(val) -// >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2") -// >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None) -// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) -// -// Note that with the default ``encoding="bytes"``, the inputs to the -// converter function are latin-1 encoded byte strings. To deactivate the -// implicit encoding prior to conversion, use ``encoding=None`` -// -// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') -// >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x) -// >>> np.loadtxt(s, converters=conv, encoding=None) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) -// -// Support for quoted fields is enabled with the `quotechar` parameter. -// Comment and delimiter characters are ignored when they appear within a -// quoted item delineated by `quotechar`: -// -// >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n') -// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) -// >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"') -// array([('alpha, #42', 10.), ('beta, #64', 2.)], -// dtype=[('label', '>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n') -// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) -// >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"') -// array([('alpha, #42', 10.), ('beta, #64', 2.)], -// dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"') -// >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"') -// array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20") -// >>> np.loadtxt(d, usecols=(0, 1)) -// array([[ 1., 2.], -// [ 2., 4.], -// [ 3., 9.], -// [ 4., 16.]]) -// -// -// -//go:linkname Loadtxt py.loadtxt -func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object -// -// Load data from a text file, with missing values handled as specified. -// -// Each line past the first `skip_header` lines is split at the `delimiter` -// character, and characters following the `comments` character are discarded. -// -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : dtype, optional -// Data type of the resulting array. -// If None, the dtypes will be determined by the contents of each -// column, individually. -// comments : str, optional -// The character used to indicate the start of a comment. -// All the characters occurring on a line after a comment are discarded. -// delimiter : str, int, or sequence, optional -// The string used to separate values. By default, any consecutive -// whitespaces act as delimiter. An integer or sequence of integers -// can also be provided as width(s) of each field. -// skiprows : int, optional -// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. -// skip_header : int, optional -// The number of lines to skip at the beginning of the file. -// skip_footer : int, optional -// The number of lines to skip at the end of the file. -// converters : variable, optional -// The set of functions that convert the data of a column to a value. -// The converters can also be used to provide a default value -// for missing data: ``converters = {3: lambda s: float(s or 0)}``. -// missing : variable, optional -// `missing` was removed in numpy 1.10. Please use `missing_values` -// instead. -// missing_values : variable, optional -// The set of strings corresponding to missing data. -// filling_values : variable, optional -// The set of values to be used as default when the data are missing. -// usecols : sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. -// names : {None, True, str, sequence}, optional -// If `names` is True, the field names are read from the first line after -// the first `skip_header` lines. This line can optionally be preceded -// by a comment delimiter. If `names` is a sequence or a single-string of -// comma-separated names, the names will be used to define the field names -// in a structured dtype. If `names` is None, the names of the dtype -// fields will be used, if any. -// excludelist : sequence, optional -// A list of names to exclude. This list is appended to the default list -// ['return','file','print']. Excluded names are appended with an -// underscore: for example, `file` would become `file_`. -// deletechars : str, optional -// A string combining invalid characters that must be deleted from the -// names. -// defaultfmt : str, optional -// A format used to define default field names, such as "f%i" or "f_%02i". -// autostrip : bool, optional -// Whether to automatically strip white spaces from the variables. -// replace_space : char, optional -// Character(s) used in replacement of white spaces in the variable -// names. By default, use a '_'. -// case_sensitive : {True, False, 'upper', 'lower'}, optional -// If True, field names are case sensitive. -// If False or 'upper', field names are converted to upper case. -// If 'lower', field names are converted to lower case. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = genfromtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// usemask : bool, optional -// If True, return a masked array. -// If False, return a regular array. -// loose : bool, optional -// If True, do not raise errors for invalid values. -// invalid_raise : bool, optional -// If True, an exception is raised if an inconsistency is detected in the -// number of columns. -// If False, a warning is emitted and the offending lines are skipped. -// max_rows : int, optional -// The maximum number of rows to read. Must not be used with skip_footer -// at the same time. If given, the value must be at least 1. Default is -// to read the entire file. -// -// .. versionadded:: 1.10.0 -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply when `fname` is -// a file object. The special value 'bytes' enables backward compatibility -// workarounds that ensure that you receive byte arrays when possible -// and passes latin1 encoded strings to converters. Override this value to -// receive unicode arrays and pass strings as input to converters. If set -// to None the system default is used. The default value is 'bytes'. -// -// .. versionadded:: 1.14.0 -// ndmin : int, optional -// Same parameter as `loadtxt` -// -// .. versionadded:: 1.23.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Data read from the text file. If `usemask` is True, this is a -// masked array. -// -// See Also -// -------- -// numpy.loadtxt : equivalent function when no data is missing. -// -// Notes -// ----- -// * When spaces are used as delimiters, or when no delimiter has been given -// as input, there should not be any missing data between two fields. -// * When the variables are named (either by a flexible dtype or with `names`), -// there must not be any header in the file (else a ValueError -// exception is raised). -// * Individual values are not stripped of spaces by default. -// When using a custom converter, make sure the function does remove spaces. -// -// References -// ---------- -// .. [1] NumPy User Guide, section `I/O with NumPy -// `_. -// -// Examples -// -------- -// >>> from io import StringIO -// >>> import numpy as np -// -// Comma delimited file with mixed dtype -// -// >>> s = StringIO(u"1,1.3,abcde") -// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), -// ... ('mystring','S5')], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only -// >>> data = np.genfromtxt(s, dtype=None, -// ... names = ['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) -// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", -// ... names=['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> s = StringIO(u"11.3abcde") -// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], -// ... delimiter=[1,3,5]) -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('intvar', '>> f = StringIO(''' -// ... text,# of chars -// ... hello world,11 -// ... numpy,5''') -// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') -// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], -// dtype=[('f0', 'S12'), ('f1', 'S12')]) -// -// -// -//go:linkname Genfromtxt py.genfromtxt -func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object -// -// Load ASCII data from a file and return it in a record array. -// -// If ``usemask=False`` a standard `recarray` is returned, -// if ``usemask=True`` a MaskedRecords array is returned. -// -// Parameters -// ---------- -// fname, kwargs : For a description of input parameters, see `genfromtxt`. -// -// See Also -// -------- -// numpy.genfromtxt : generic function -// -// Notes -// ----- -// By default, `dtype` is None, which means that the data-type of the output -// array will be determined from the data. -// -// -// -//go:linkname Recfromtxt py.recfromtxt -func Recfromtxt(fname *py.Object) *py.Object -// -// Load ASCII data stored in a comma-separated file. -// -// The returned array is a record array (if ``usemask=False``, see -// `recarray`) or a masked record array (if ``usemask=True``, -// see `ma.mrecords.MaskedRecords`). -// -// Parameters -// ---------- -// fname, kwargs : For a description of input parameters, see `genfromtxt`. -// -// See Also -// -------- -// numpy.genfromtxt : generic function to load ASCII data. -// -// Notes -// ----- -// By default, `dtype` is None, which means that the data-type of the output -// array will be determined from the data. -// -// -// -//go:linkname Recfromcsv py.recfromcsv -func Recfromcsv(fname *py.Object) *py.Object -// -// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. -// -// .. warning:: Loading files that contain object arrays uses the ``pickle`` -// module, which is not secure against erroneous or maliciously -// constructed data. Consider passing ``allow_pickle=False`` to -// load data that is known not to contain object arrays for the -// safer handling of untrusted sources. -// -// Parameters -// ---------- -// file : file-like object, string, or pathlib.Path -// The file to read. File-like objects must support the -// ``seek()`` and ``read()`` methods and must always -// be opened in binary mode. Pickled files require that the -// file-like object support the ``readline()`` method as well. -// mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional -// If not None, then memory-map the file, using the given mode (see -// `numpy.memmap` for a detailed description of the modes). A -// memory-mapped array is kept on disk. However, it can be accessed -// and sliced like any ndarray. Memory mapping is especially useful -// for accessing small fragments of large files without reading the -// entire file into memory. -// allow_pickle : bool, optional -// Allow loading pickled object arrays stored in npy files. Reasons for -// disallowing pickles include security, as loading pickled data can -// execute arbitrary code. If pickles are disallowed, loading object -// arrays will fail. Default: False -// -// .. versionchanged:: 1.16.3 -// Made default False in response to CVE-2019-6446. -// -// fix_imports : bool, optional -// Only useful when loading Python 2 generated pickled files on Python 3, -// which includes npy/npz files containing object arrays. If `fix_imports` -// is True, pickle will try to map the old Python 2 names to the new names -// used in Python 3. -// encoding : str, optional -// What encoding to use when reading Python 2 strings. Only useful when -// loading Python 2 generated pickled files in Python 3, which includes -// npy/npz files containing object arrays. Values other than 'latin1', -// 'ASCII', and 'bytes' are not allowed, as they can corrupt numerical -// data. Default: 'ASCII' -// max_header_size : int, optional -// Maximum allowed size of the header. Large headers may not be safe -// to load securely and thus require explicitly passing a larger value. -// See :py:func:`ast.literal_eval()` for details. -// This option is ignored when `allow_pickle` is passed. In that case -// the file is by definition trusted and the limit is unnecessary. -// -// Returns -// ------- -// result : array, tuple, dict, etc. -// Data stored in the file. For ``.npz`` files, the returned instance -// of NpzFile class must be closed to avoid leaking file descriptors. -// -// Raises -// ------ -// OSError -// If the input file does not exist or cannot be read. -// UnpicklingError -// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. -// ValueError -// The file contains an object array, but ``allow_pickle=False`` given. -// EOFError -// When calling ``np.load`` multiple times on the same file handle, -// if all data has already been read -// -// See Also -// -------- -// save, savez, savez_compressed, loadtxt -// memmap : Create a memory-map to an array stored in a file on disk. -// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. -// -// Notes -// ----- -// - If the file contains pickle data, then whatever object is stored -// in the pickle is returned. -// - If the file is a ``.npy`` file, then a single array is returned. -// - If the file is a ``.npz`` file, then a dictionary-like object is -// returned, containing ``{filename: array}`` key-value pairs, one for -// each file in the archive. -// - If the file is a ``.npz`` file, the returned value supports the -// context manager protocol in a similar fashion to the open function:: -// -// with load('foo.npz') as data: -// a = data['a'] -// -// The underlying file descriptor is closed when exiting the 'with' -// block. -// -// Examples -// -------- -// Store data to disk, and load it again: -// -// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) -// >>> np.load('/tmp/123.npy') -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// Store compressed data to disk, and load it again: -// -// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) -// >>> b=np.array([1, 2]) -// >>> np.savez('/tmp/123.npz', a=a, b=b) -// >>> data = np.load('/tmp/123.npz') -// >>> data['a'] -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> data['b'] -// array([1, 2]) -// >>> data.close() -// -// Mem-map the stored array, and then access the second row -// directly from disk: -// -// >>> X = np.load('/tmp/123.npy', mmap_mode='r') -// >>> X[1, :] -// memmap([4, 5, 6]) -// -// -// -//go:linkname Load py.load -func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object -// -// Build a matrix object from a string, nested sequence, or array. -// -// Parameters -// ---------- -// obj : str or array_like -// Input data. If a string, variables in the current scope may be -// referenced by name. -// ldict : dict, optional -// A dictionary that replaces local operands in current frame. -// Ignored if `obj` is not a string or `gdict` is None. -// gdict : dict, optional -// A dictionary that replaces global operands in current frame. -// Ignored if `obj` is not a string. -// -// Returns -// ------- -// out : matrix -// Returns a matrix object, which is a specialized 2-D array. -// -// See Also -// -------- -// block : -// A generalization of this function for N-d arrays, that returns normal -// ndarrays. -// -// Examples -// -------- -// >>> A = np.mat('1 1; 1 1') -// >>> B = np.mat('2 2; 2 2') -// >>> C = np.mat('3 4; 5 6') -// >>> D = np.mat('7 8; 9 0') -// -// All the following expressions construct the same block matrix: -// -// >>> np.bmat([[A, B], [C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat('A,B; C,D') -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// -// -// -//go:linkname Bmat py.bmat -func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object -// -// Interpret the input as a matrix. -// -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. -// -// Parameters -// ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. -// -// Returns -// ------- -// mat : matrix -// `data` interpreted as a matrix. -// -// Examples -// -------- -// >>> x = np.array([[1, 2], [3, 4]]) -// -// >>> m = np.asmatrix(x) -// -// >>> x[0,0] = 5 -// -// >>> m -// matrix([[5, 2], -// [3, 4]]) -// -// -// -//go:linkname Mat py.mat -func Mat(data *py.Object, dtype *py.Object) *py.Object -// -// Interpret the input as a matrix. -// -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. -// -// Parameters -// ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. -// -// Returns -// ------- -// mat : matrix -// `data` interpreted as a matrix. -// -// Examples -// -------- -// >>> x = np.array([[1, 2], [3, 4]]) -// -// >>> m = np.asmatrix(x) -// -// >>> x[0,0] = 5 -// -// >>> m -// matrix([[5, 2], -// [3, 4]]) -// -// -// -//go:linkname Asmatrix py.asmatrix -func Asmatrix(data *py.Object, dtype *py.Object) *py.Object -// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the absolute value element-wise. -// -// ``np.abs`` is a shorthand for this function. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// absolute : ndarray -// An ndarray containing the absolute value of -// each element in `x`. For complex input, ``a + ib``, the -// absolute value is :math:`\sqrt{ a^2 + b^2 }`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> x = np.array([-1.2, 1.2]) -// >>> np.absolute(x) -// array([ 1.2, 1.2]) -// >>> np.absolute(1.2 + 1j) -// 1.5620499351813308 -// -// Plot the function over ``[-10, 10]``: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(start=-10, stop=10, num=101) -// >>> plt.plot(x, np.absolute(x)) -// >>> plt.show() -// -// Plot the function over the complex plane: -// -// >>> xx = x + 1j * x[:, np.newaxis] -// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') -// >>> plt.show() -// -// The `abs` function can be used as a shorthand for ``np.absolute`` on -// ndarrays. -// -// >>> x = np.array([-1.2, 1.2]) -// >>> abs(x) -// array([1.2, 1.2]) -// -//go:linkname Abs py.abs -func Abs(__llgo_va_list ...interface{}) *py.Object diff --git a/numpy/numpy_autogen_link.go b/numpy/numpy_autogen_link.go deleted file mode 100644 index bb5882ce..00000000 --- a/numpy/numpy_autogen_link.go +++ /dev/null @@ -1,5 +0,0 @@ -package numpy - -import _ "github.com/goplus/lib/py" - -// LLGoPackage is defined in the main binding file diff --git a/numpy_1/_demo/go.mod b/numpy_1/_demo/go.mod deleted file mode 100644 index 46f5f92f..00000000 --- a/numpy_1/_demo/go.mod +++ /dev/null @@ -1,10 +0,0 @@ -module test_math3 - -go 1.24.5 - -replace github.com/goplus/llpkg/math => ../ - -require ( - github.com/goplus/lib v0.2.0 - github.com/goplus/llpkg/math v0.0.0-00010101000000-000000000000 -) diff --git a/numpy_1/_demo/go.sum b/numpy_1/_demo/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/numpy_1/_demo/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy_1/_demo/main.go b/numpy_1/_demo/main.go deleted file mode 100644 index c34d0173..00000000 --- a/numpy_1/_demo/main.go +++ /dev/null @@ -1,11 +0,0 @@ -package main - -import ( - "github.com/goplus/lib/py" -) - -func main() { - // 初始化 Python - py.Initialize() - defer py.Finalize() -} diff --git a/numpy_1/go.mod b/numpy_1/go.mod deleted file mode 100644 index 82bc5445..00000000 --- a/numpy_1/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/goplus/llpkg/numpy - -go 1.23 - -require github.com/goplus/lib v0.2.0 diff --git a/numpy_1/go.sum b/numpy_1/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/numpy_1/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy_1/llpkg.cfg b/numpy_1/llpkg.cfg deleted file mode 100644 index 8356bfc2..00000000 --- a/numpy_1/llpkg.cfg +++ /dev/null @@ -1,16 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "python_version": "3.12", - "index_url": "https://pypi.org/simple/" - } - }, - "package": { - "name": "numpy", - "version": "builtin" - } - } -} \ No newline at end of file diff --git a/numpy_1/llpyg.cfg b/numpy_1/llpyg.cfg deleted file mode 100644 index b8888a8d..00000000 --- a/numpy_1/llpyg.cfg +++ /dev/null @@ -1,155 +0,0 @@ -{ - "name": "numpy", - "module": "numpy", - "python": true, - "symMap": { - "abs": "Abs", - "absolute": "Absolute", - "add": "Add", - "all": "All", - "any": "Any", - "arange": "Arange", - "arccos": "Arccos", - "arccosh": "Arccosh", - "arcsin": "Arcsin", - "arcsinh": "Arcsinh", - "arctan": "Arctan", - "arctanh": "Arctanh", - "array": "Array", - "average": "Average", - "bin": "Bin", - "bool": "Bool", - "c_": "C", - "ceil": "Ceil", - "chr": "Chr", - "corrcoef": "Corrcoef", - "cos": "Cos", - "cosh": "Cosh", - "cov": "Cov", - "cross": "Cross", - "diag": "Diag", - "dict": "Dict", - "dir": "Dir", - "divide": "Divide", - "dot": "Dot", - "einsum": "Einsum", - "empty": "Empty", - "enumerate": "Enumerate", - "exp": "Exp", - "eye": "Eye", - "fabs": "Fabs", - "fft": "Fft", - "filter": "Filter", - "float": "Float", - "floor": "Floor", - "format": "Format", - "frozenset": "FrozenSet", - "getattr": "GetAttr", - "hasattr": "HasAttr", - "hash": "Hash", - "help": "Help", - "hex": "Hex", - "id": "ID", - "identity": "Identity", - "inner": "Inner", - "input": "Input", - "int": "Int", - "isinstance": "IsInstance", - "issubclass": "IsSubclass", - "iter": "Iter", - "len": "Len", - "linalg": "Linalg", - "linspace": "Linspace", - "list": "List", - "locals": "Locals", - "log": "Log", - "log10": "Log10", - "log2": "Log2", - "logspace": "Logspace", - "map": "Map", - "matmul": "Matmul", - "max": "Max", - "mean": "Mean", - "median": "Median", - "meshgrid": "Meshgrid", - "mgrid": "Mgrid", - "min": "Min", - "mod": "Mod", - "multiply": "Multiply", - "next": "Next", - "oct": "Oct", - "ogrid": "Ogrid", - "ones": "Ones", - "open": "Open", - "ord": "Ord", - "outer": "Outer", - "percentile": "Percentile", - "pow": "Pow", - "power": "Power", - "print": "Print", - "prod": "Prod", - "ptp": "Ptp", - "quantile": "Quantile", - "r_": "R", - "random": "Random", - "range": "Range", - "remainder": "Remainder", - "repr": "Repr", - "reversed": "Reversed", - "rint": "Rint", - "round": "Round", - "set": "Set", - "setattr": "SetAttr", - "sign": "Sign", - "sin": "Sin", - "sinh": "Sinh", - "sorted": "Sorted", - "sqrt": "Sqrt", - "std": "Std", - "str": "Str", - "subtract": "Subtract", - "sum": "Sum", - "tan": "Tan", - "tanh": "Tanh", - "tensordot": "Tensordot", - "tri": "Tri", - "tril": "Tril", - "triu": "Triu", - "trunc": "Trunc", - "tuple": "Tuple", - "type": "Type", - "vander": "Vander", - "var": "Var", - "vars": "Vars", - "zeros": "Zeros", - "zip": "Zip" - }, - "deps": [ - "py" - ], - "include": [ - "numpy" - ], - "exclude": [ - "__builtins__", - "__cached__", - "__doc__", - "__file__", - "__loader__", - "__name__", - "__package__", - "__spec__" - ], - "constants": { - "bool_": "Bool", - "e": "E", - "float32": "Float32", - "float64": "Float64", - "inf": "Inf", - "int32": "Int32", - "int64": "Int64", - "nan": "NaN", - "pi": "Pi", - "uint8": "Uint8" - } -} \ No newline at end of file diff --git a/numpy_1/numpy.go b/numpy_1/numpy.go deleted file mode 100644 index a8146d45..00000000 --- a/numpy_1/numpy.go +++ /dev/null @@ -1,9589 +0,0 @@ -package numpy - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -const LLGoPackage = "py.numpy" -// -// Show libraries and system information on which NumPy was built -// and is being used -// -// Parameters -// ---------- -// mode : {`'stdout'`, `'dicts'`}, optional. -// Indicates how to display the config information. -// `'stdout'` prints to console, `'dicts'` returns a dictionary -// of the configuration. -// -// Returns -// ------- -// out : {`dict`, `None`} -// If mode is `'dicts'`, a dict is returned, else None -// -// See Also -// -------- -// get_include : Returns the directory containing NumPy C -// header files. -// -// Notes -// ----- -// 1. The `'stdout'` mode will give more readable -// output if ``pyyaml`` is installed -// -// -// -//go:linkname ShowConfig py.show_config -func ShowConfig(mode *py.Object) *py.Object -// -// Check 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. -// -// Parameters -// ---------- -// a : ndarray -// Input array. -// -// Returns -// ------- -// isfortran : bool -// Returns True if the array is Fortran contiguous but *not* C contiguous. -// -// -// Examples -// -------- -// -// np.array allows to specify whether the array is written in C-contiguous -// order (last index varies the fastest), or FORTRAN-contiguous order in -// memory (first index varies the fastest). -// -// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(a) -// False -// -// >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') -// >>> b -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(b) -// True -// -// -// The transpose of a C-ordered array is a FORTRAN-ordered array. -// -// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(a) -// False -// >>> b = a.T -// >>> b -// array([[1, 4], -// [2, 5], -// [3, 6]]) -// >>> np.isfortran(b) -// True -// -// C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. -// -// >>> np.isfortran(np.array([1, 2], order='F')) -// False -// -// -// -//go:linkname Isfortran py.isfortran -func Isfortran(a *py.Object) *py.Object -// -// Return an array representing the indices of a grid. -// -// Compute an array where the subarrays contain index values 0, 1, ... -// varying only along the corresponding axis. -// -// Parameters -// ---------- -// dimensions : sequence of ints -// The shape of the grid. -// dtype : dtype, optional -// Data type of the result. -// sparse : boolean, optional -// Return a sparse representation of the grid instead of a dense -// representation. Default is False. -// -// .. versionadded:: 1.17 -// -// Returns -// ------- -// grid : one ndarray or tuple of ndarrays -// If sparse is False: -// Returns one array of grid indices, -// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. -// If sparse is True: -// Returns a tuple of arrays, with -// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with -// dimensions[i] in the ith place -// -// See Also -// -------- -// mgrid, ogrid, meshgrid -// -// Notes -// ----- -// The output shape in the dense case is obtained by prepending the number -// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` -// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is -// ``(N, r0, ..., rN-1)``. -// -// The subarrays ``grid[k]`` contains the N-D array of indices along the -// ``k-th`` axis. Explicitly:: -// -// grid[k, i0, i1, ..., iN-1] = ik -// -// Examples -// -------- -// >>> grid = np.indices((2, 3)) -// >>> grid.shape -// (2, 2, 3) -// >>> grid[0] # row indices -// array([[0, 0, 0], -// [1, 1, 1]]) -// >>> grid[1] # column indices -// array([[0, 1, 2], -// [0, 1, 2]]) -// -// The indices can be used as an index into an array. -// -// >>> x = np.arange(20).reshape(5, 4) -// >>> row, col = np.indices((2, 3)) -// >>> x[row, col] -// array([[0, 1, 2], -// [4, 5, 6]]) -// -// Note that it would be more straightforward in the above example to -// extract the required elements directly with ``x[:2, :3]``. -// -// If sparse is set to true, the grid will be returned in a sparse -// representation. -// -// >>> i, j = np.indices((2, 3), sparse=True) -// >>> i.shape -// (2, 1) -// >>> j.shape -// (1, 3) -// >>> i # row indices -// array([[0], -// [1]]) -// >>> j # column indices -// array([[0, 1, 2]]) -// -// -// -//go:linkname Indices py.indices -func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object -// -// Construct an array by executing a function over each coordinate. -// -// The resulting array therefore has a value ``fn(x, y, z)`` at -// coordinate ``(x, y, z)``. -// -// Parameters -// ---------- -// function : callable -// The function is called with N parameters, where N is the rank of -// `shape`. Each parameter represents the coordinates of the array -// varying along a specific axis. For example, if `shape` -// were ``(2, 2)``, then the parameters would be -// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` -// shape : (N,) tuple of ints -// Shape of the output array, which also determines the shape of -// the coordinate arrays passed to `function`. -// dtype : data-type, optional -// Data-type of the coordinate arrays passed to `function`. -// By default, `dtype` is float. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// fromfunction : any -// The result of the call to `function` is passed back directly. -// Therefore the shape of `fromfunction` is completely determined by -// `function`. If `function` returns a scalar value, the shape of -// `fromfunction` would not match the `shape` parameter. -// -// See Also -// -------- -// indices, meshgrid -// -// Notes -// ----- -// Keywords other than `dtype` and `like` are passed to `function`. -// -// Examples -// -------- -// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) -// array([[0., 0.], -// [1., 1.]]) -// -// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) -// array([[0., 1.], -// [0., 1.]]) -// -// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) -// array([[ True, False, False], -// [False, True, False], -// [False, False, True]]) -// -// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) -// array([[0, 1, 2], -// [1, 2, 3], -// [2, 3, 4]]) -// -// -// -//go:linkname Fromfunction py.fromfunction -func Fromfunction(function *py.Object, shape *py.Object) *py.Object -// -// Returns True if the type of `element` is a scalar type. -// -// Parameters -// ---------- -// element : any -// Input argument, can be of any type and shape. -// -// Returns -// ------- -// val : bool -// True if `element` is a scalar type, False if it is not. -// -// See Also -// -------- -// ndim : Get the number of dimensions of an array -// -// Notes -// ----- -// If you need a stricter way to identify a *numerical* scalar, use -// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most -// non-numerical elements such as strings. -// -// In most 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: -// -// +--------------------------------------+---------------+-------------------+ -// | x |``isscalar(x)``|``np.ndim(x) == 0``| -// +======================================+===============+===================+ -// | PEP 3141 numeric objects (including | ``True`` | ``True`` | -// | builtins) | | | -// +--------------------------------------+---------------+-------------------+ -// | builtin string and buffer objects | ``True`` | ``True`` | -// +--------------------------------------+---------------+-------------------+ -// | other builtin objects, like | ``False`` | ``True`` | -// | `pathlib.Path`, `Exception`, | | | -// | the result of `re.compile` | | | -// +--------------------------------------+---------------+-------------------+ -// | third-party objects like | ``False`` | ``True`` | -// | `matplotlib.figure.Figure` | | | -// +--------------------------------------+---------------+-------------------+ -// | zero-dimensional numpy arrays | ``False`` | ``True`` | -// +--------------------------------------+---------------+-------------------+ -// | other numpy arrays | ``False`` | ``False`` | -// +--------------------------------------+---------------+-------------------+ -// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | -// | objects | | | -// +--------------------------------------+---------------+-------------------+ -// -// Examples -// -------- -// >>> np.isscalar(3.1) -// True -// >>> np.isscalar(np.array(3.1)) -// False -// >>> np.isscalar([3.1]) -// False -// >>> np.isscalar(False) -// True -// >>> np.isscalar('numpy') -// True -// -// NumPy supports PEP 3141 numbers: -// -// >>> from fractions import Fraction -// >>> np.isscalar(Fraction(5, 17)) -// True -// >>> from numbers import Number -// >>> np.isscalar(Number()) -// True -// -// -// -//go:linkname Isscalar py.isscalar -func Isscalar(element *py.Object) *py.Object -// -// Return the binary representation of the input number as a string. -// -// For negative numbers, if width is not given, a minus sign is added to the -// front. If width is given, the two's complement of the number is -// returned, with respect to that width. -// -// In a two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit two's-complement -// system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// num : int -// Only an integer decimal number can be used. -// width : int, optional -// The length of the returned string if `num` is positive, or the length -// of the two's complement if `num` is negative, provided that `width` is -// at least a sufficient number of bits for `num` to be represented in the -// designated form. -// -// If the `width` value is insufficient, it will be ignored, and `num` will -// be returned in binary (`num` > 0) or two's complement (`num` < 0) form -// with its width equal to the minimum number of bits needed to represent -// the number in the designated form. This behavior is deprecated and will -// later raise an error. -// -// .. deprecated:: 1.12.0 -// -// Returns -// ------- -// bin : str -// Binary representation of `num` or two's complement of `num`. -// -// See Also -// -------- -// base_repr: Return a string representation of a number in the given base -// system. -// bin: Python's built-in binary representation generator of an integer. -// -// Notes -// ----- -// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x -// faster. -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// >>> np.binary_repr(3) -// '11' -// >>> np.binary_repr(-3) -// '-11' -// >>> np.binary_repr(3, width=4) -// '0011' -// -// The two's complement is returned when the input number is negative and -// width is specified: -// -// >>> np.binary_repr(-3, width=3) -// '101' -// >>> np.binary_repr(-3, width=5) -// '11101' -// -// -// -//go:linkname BinaryRepr py.binary_repr -func BinaryRepr(num *py.Object, width *py.Object) *py.Object -// -// Return a string representation of a number in the given base system. -// -// Parameters -// ---------- -// number : int -// The value to convert. Positive and negative values are handled. -// base : int, optional -// Convert `number` to the `base` number system. The valid range is 2-36, -// the default value is 2. -// padding : int, optional -// Number of zeros padded on the left. Default is 0 (no padding). -// -// Returns -// ------- -// out : str -// String representation of `number` in `base` system. -// -// See Also -// -------- -// binary_repr : Faster version of `base_repr` for base 2. -// -// Examples -// -------- -// >>> np.base_repr(5) -// '101' -// >>> np.base_repr(6, 5) -// '11' -// >>> np.base_repr(7, base=5, padding=3) -// '00012' -// -// >>> np.base_repr(10, base=16) -// 'A' -// >>> np.base_repr(32, base=16) -// '20' -// -// -// -//go:linkname BaseRepr py.base_repr -func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object -// -// Return a new array of given shape and type, filled with ones. -// -// Parameters -// ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// The desired data-type for the array, e.g., `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: C -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of ones with the given shape, dtype, and order. -// -// See Also -// -------- -// ones_like : Return an array of ones with shape and type of input. -// empty : Return a new uninitialized array. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. -// -// -// Examples -// -------- -// >>> np.ones(5) -// array([1., 1., 1., 1., 1.]) -// -// >>> np.ones((5,), dtype=int) -// array([1, 1, 1, 1, 1]) -// -// >>> np.ones((2, 1)) -// array([[1.], -// [1.]]) -// -// >>> s = (2,2) -// >>> np.ones(s) -// array([[1., 1.], -// [1., 1.]]) -// -// -// -//go:linkname Ones py.ones -func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Return the identity array. -// -// The identity array is a square array with ones on -// the main diagonal. -// -// Parameters -// ---------- -// n : int -// Number of rows (and columns) in `n` x `n` output. -// dtype : data-type, optional -// Data-type of the output. Defaults to ``float``. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// `n` x `n` array with its main diagonal set to one, -// and all other elements 0. -// -// Examples -// -------- -// >>> np.identity(3) -// array([[1., 0., 0.], -// [0., 1., 0.], -// [0., 0., 1.]]) -// -// -// -//go:linkname Identity py.identity -func Identity(n *py.Object, dtype *py.Object) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute bit-wise inversion, or bit-wise NOT, element-wise. -// -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. -// -// For signed integer inputs, the two's complement is returned. In a -// two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit -// two's-complement system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Notes -// ----- -// `bitwise_not` is an alias for `invert`: -// -// >>> np.bitwise_not is np.invert -// True -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: -// -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// 242 -// >>> np.binary_repr(x, width=8) -// '11110010' -// -// The result depends on the bit-width: -// -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// 65522 -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types the result is the two's complement of -// the result for the unsigned type: -// -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' -// -// Booleans are accepted as well: -// -// >>> np.invert(np.array([True, False])) -// array([False, True]) -// -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. -// -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) -// -//go:linkname BitwiseNot py.bitwise_not -func BitwiseNot(__llgo_va_list ...interface{}) *py.Object -// -// Return a new array of given shape and type, filled with `fill_value`. -// -// Parameters -// ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// fill_value : scalar or array_like -// Fill value. -// dtype : data-type, optional -// The desired data-type for the array The default, None, means -// ``np.array(fill_value).dtype``. -// order : {'C', 'F'}, optional -// Whether to store multidimensional data in C- or Fortran-contiguous -// (row- or column-wise) order in memory. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of `fill_value` with the given shape, dtype, and order. -// -// See Also -// -------- -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. -// -// Examples -// -------- -// >>> np.full((2, 2), np.inf) -// array([[inf, inf], -// [inf, inf]]) -// >>> np.full((2, 2), 10) -// array([[10, 10], -// [10, 10]]) -// -// >>> np.full((2, 2), [1, 2]) -// array([[1, 2], -// [1, 2]]) -// -// -// -//go:linkname Full py.full -func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object -// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) -// -// Matrix product of two arrays. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays, scalars not allowed. -// out : ndarray, optional -// A location into which the result is stored. If provided, it must have -// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not -// provided or None, a freshly-allocated array is returned. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// .. versionadded:: 1.16 -// Now handles ufunc kwargs -// -// Returns -// ------- -// y : ndarray -// The matrix product of the inputs. -// This is a scalar only when both x1, x2 are 1-d vectors. -// -// Raises -// ------ -// ValueError -// If the last dimension of `x1` is not the same size as -// the second-to-last dimension of `x2`. -// -// If a scalar value is passed in. -// -// See Also -// -------- -// vdot : Complex-conjugating dot product. -// tensordot : Sum products over arbitrary axes. -// einsum : Einstein summation convention. -// dot : alternative matrix product with different broadcasting rules. -// -// Notes -// ----- -// -// The behavior depends on the arguments in the following way. -// -// - If both arguments are 2-D they are multiplied like conventional -// matrices. -// - If either argument is N-D, N > 2, it is treated as a stack of -// matrices residing in the last two indexes and broadcast accordingly. -// - If the first argument is 1-D, it is promoted to a matrix by -// prepending a 1 to its dimensions. After matrix multiplication -// the prepended 1 is removed. -// - If the second argument is 1-D, it is promoted to a matrix by -// appending a 1 to its dimensions. After matrix multiplication -// the appended 1 is removed. -// -// ``matmul`` differs from ``dot`` in two important ways: -// -// - Multiplication by scalars is not allowed, use ``*`` instead. -// - Stacks of matrices are broadcast together as if the matrices -// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: -// -// >>> a = np.ones([9, 5, 7, 4]) -// >>> c = np.ones([9, 5, 4, 3]) -// >>> np.dot(a, c).shape -// (9, 5, 7, 9, 5, 3) -// >>> np.matmul(a, c).shape -// (9, 5, 7, 3) -// >>> # n is 7, k is 4, m is 3 -// -// The matmul function implements the semantics of the ``@`` operator -// introduced in Python 3.5 following :pep:`465`. -// -// It uses an optimized BLAS library when possible (see `numpy.linalg`). -// -// Examples -// -------- -// For 2-D arrays it is the matrix product: -// -// >>> a = np.array([[1, 0], -// ... [0, 1]]) -// >>> b = np.array([[4, 1], -// ... [2, 2]]) -// >>> np.matmul(a, b) -// array([[4, 1], -// [2, 2]]) -// -// For 2-D mixed with 1-D, the result is the usual. -// -// >>> a = np.array([[1, 0], -// ... [0, 1]]) -// >>> b = np.array([1, 2]) -// >>> np.matmul(a, b) -// array([1, 2]) -// >>> np.matmul(b, a) -// array([1, 2]) -// -// -// Broadcasting is conventional for stacks of arrays -// -// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) -// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) -// >>> np.matmul(a,b).shape -// (2, 2, 2) -// >>> np.matmul(a, b)[0, 1, 1] -// 98 -// >>> sum(a[0, 1, :] * b[0 , :, 1]) -// 98 -// -// Vector, vector returns the scalar inner product, but neither argument -// is complex-conjugated: -// -// >>> np.matmul([2j, 3j], [2j, 3j]) -// (-13+0j) -// -// Scalar multiplication raises an error. -// -// >>> np.matmul([1,2], 3) -// Traceback (most recent call last): -// ... -// ValueError: matmul: Input operand 1 does not have enough dimensions ... -// -// The ``@`` operator can be used as a shorthand for ``np.matmul`` on -// ndarrays. -// -// >>> x1 = np.array([2j, 3j]) -// >>> x2 = np.array([2j, 3j]) -// >>> x1 @ x2 -// (-13+0j) -// -// .. versionadded:: 1.10.0 -// -//go:linkname Matmul py.matmul -func Matmul(__llgo_va_list ...interface{}) *py.Object -// arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric inverse cosine, element-wise. -// -// The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``. -// -// Parameters -// ---------- -// x : array_like -// `x`-coordinate on the unit circle. -// For real arguments, the domain is [-1, 1]. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// The angle of the ray intersecting the unit circle at the given -// `x`-coordinate in radians [0, pi]. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// cos, arctan, arcsin, emath.arccos -// -// Notes -// ----- -// `arccos` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``cos(z) = x``. The convention is to return -// the angle `z` whose real part lies in `[0, pi]`. -// -// For real-valued input data types, `arccos` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse `cos` is also known as `acos` or cos^-1. -// -// References -// ---------- -// M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// We expect the arccos of 1 to be 0, and of -1 to be pi: -// -// >>> np.arccos([1, -1]) -// array([ 0. , 3.14159265]) -// -// Plot arccos: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-1, 1, num=100) -// >>> plt.plot(x, np.arccos(x)) -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Arccos py.arccos -func Arccos(__llgo_va_list ...interface{}) *py.Object -// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic cosine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// arccosh : ndarray -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// -// cosh, arcsinh, sinh, arctanh, tanh -// -// Notes -// ----- -// `arccosh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `cosh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in -// ``[0, inf]``. -// -// For real-valued input data types, `arccosh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arccosh` is a complex analytical function that -// has a branch cut `[-inf, 1]` and is continuous from above on it. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arccosh -// -// Examples -// -------- -// >>> np.arccosh([np.e, 10.0]) -// array([ 1.65745445, 2.99322285]) -// >>> np.arccosh(1) -// 0.0 -// -//go:linkname Arccosh py.arccosh -func Arccosh(__llgo_va_list ...interface{}) *py.Object -// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse sine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// `y`-coordinate on the unit circle. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// The inverse sine of each element in `x`, in radians and in the -// closed interval ``[-pi/2, pi/2]``. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin -// -// Notes -// ----- -// `arcsin` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that :math:`sin(z) = x`. The convention is to -// return the angle `z` whose real part lies in [-pi/2, pi/2]. -// -// For real-valued input data types, *arcsin* always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse sine is also known as `asin` or sin^{-1}. -// -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79ff. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// >>> np.arcsin(1) # pi/2 -// 1.5707963267948966 -// >>> np.arcsin(-1) # -pi/2 -// -1.5707963267948966 -// >>> np.arcsin(0) -// 0.0 -// -//go:linkname Arcsin py.arcsin -func Arcsin(__llgo_va_list ...interface{}) *py.Object -// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic sine element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `arcsinh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `sinh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arcsinh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// returns ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arcsinh -// -// Examples -// -------- -// >>> np.arcsinh(np.array([np.e, 10.0])) -// array([ 1.72538256, 2.99822295]) -// -//go:linkname Arcsinh py.arcsinh -func Arcsinh(__llgo_va_list ...interface{}) *py.Object -// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric inverse tangent, element-wise. -// -// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. -// -// Parameters -// ---------- -// x : array_like -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Out has the same shape as `x`. Its real part is in -// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) -// and the positive `x`-axis. -// angle : Argument of complex values. -// -// Notes -// ----- -// `arctan` is a multi-valued function: for each `x` there are infinitely -// many numbers `z` such that tan(`z`) = `x`. The convention is to return -// the angle `z` whose real part lies in [-pi/2, pi/2]. -// -// For real-valued input data types, `arctan` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse tangent is also known as `atan` or tan^{-1}. -// -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// We expect the arctan of 0 to be 0, and of 1 to be pi/4: -// -// >>> np.arctan([0, 1]) -// array([ 0. , 0.78539816]) -// -// >>> np.pi/4 -// 0.78539816339744828 -// -// Plot arctan: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-10, 10) -// >>> plt.plot(x, np.arctan(x)) -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Arctan py.arctan -func Arctan(__llgo_va_list ...interface{}) *py.Object -// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. -// -// 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`). (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). -// -// This function is not defined for complex-valued arguments; for the -// so-called argument of complex values, use `angle`. -// -// Parameters -// ---------- -// x1 : array_like, real-valued -// `y`-coordinates. -// x2 : array_like, real-valued -// `x`-coordinates. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// Array of angles in radians, in the range ``[-pi, pi]``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// arctan, tan, angle -// -// Notes -// ----- -// *arctan2* is identical to the `atan2` function of the underlying -// C library. The following special values are defined in the C -// standard: [1]_ -// -// ====== ====== ================ -// `x1` `x2` `arctan2(x1,x2)` -// ====== ====== ================ -// +/- 0 +0 +/- 0 -// +/- 0 -0 +/- pi -// > 0 +/-inf +0 / +pi -// < 0 +/-inf -0 / -pi -// +/-inf +inf +/- (pi/4) -// +/-inf -inf +/- (3*pi/4) -// ====== ====== ================ -// -// Note that +0 and -0 are distinct floating point numbers, as are +inf -// and -inf. -// -// References -// ---------- -// .. [1] ISO/IEC standard 9899:1999, "Programming language C." -// -// Examples -// -------- -// Consider four points in different quadrants: -// -// >>> x = np.array([-1, +1, +1, -1]) -// >>> y = np.array([-1, -1, +1, +1]) -// >>> np.arctan2(y, x) * 180 / np.pi -// array([-135., -45., 45., 135.]) -// -// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 -// and at several other special points, obtaining values in -// the range ``[-pi, pi]``: -// -// >>> np.arctan2([1., -1.], [0., 0.]) -// array([ 1.57079633, -1.57079633]) -// >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) -// array([0. , 3.14159265, 0.78539816]) -// -//go:linkname Arctan2 py.arctan2 -func Arctan2(__llgo_va_list ...interface{}) *py.Object -// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic tangent element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.arctanh -// -// Notes -// ----- -// `arctanh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``tanh(z) = x``. The convention is to return -// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arctanh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arctanh -// -// Examples -// -------- -// >>> np.arctanh([0, -0.5]) -// array([ 0. , -0.54930614]) -// -//go:linkname Arctanh py.arctanh -func Arctanh(__llgo_va_list ...interface{}) *py.Object -// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise AND of two arrays element-wise. -// -// Computes the bit-wise AND of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``&``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and -// bitwise_or -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise AND of 13 and 17 is -// therefore ``000000001``, or 1: -// -// >>> np.bitwise_and(13, 17) -// 1 -// -// >>> np.bitwise_and(14, 13) -// 12 -// >>> np.binary_repr(12) -// '1100' -// >>> np.bitwise_and([14,3], 13) -// array([12, 1]) -// -// >>> np.bitwise_and([11,7], [4,25]) -// array([0, 1]) -// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) -// array([ 2, 4, 16]) -// >>> np.bitwise_and([True, True], [False, True]) -// array([False, True]) -// -// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([3, 14, 16]) -// >>> x1 & x2 -// array([ 2, 4, 16]) -// -//go:linkname BitwiseAnd py.bitwise_and -func BitwiseAnd(__llgo_va_list ...interface{}) *py.Object -// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise OR of two arrays element-wise. -// -// Computes the bit-wise OR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``|``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_or -// bitwise_and -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 has the binary representation ``00001101``. Likewise, -// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is -// then ``00011101``, or 29: -// -// >>> np.bitwise_or(13, 16) -// 29 -// >>> np.binary_repr(29) -// '11101' -// -// >>> np.bitwise_or(32, 2) -// 34 -// >>> np.bitwise_or([33, 4], 1) -// array([33, 5]) -// >>> np.bitwise_or([33, 4], [1, 2]) -// array([33, 6]) -// -// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) -// array([ 6, 5, 255]) -// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) -// array([ 6, 5, 255]) -// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), -// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) -// array([ 6, 5, 255, 2147483647]) -// >>> np.bitwise_or([True, True], [False, True]) -// array([ True, True]) -// -// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([4, 4, 4]) -// >>> x1 | x2 -// array([ 6, 5, 255]) -// -//go:linkname BitwiseOr py.bitwise_or -func BitwiseOr(__llgo_va_list ...interface{}) *py.Object -// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise XOR of two arrays element-wise. -// -// Computes the bit-wise XOR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``^``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_xor -// bitwise_and -// bitwise_or -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise XOR of 13 and 17 is -// therefore ``00011100``, or 28: -// -// >>> np.bitwise_xor(13, 17) -// 28 -// >>> np.binary_repr(28) -// '11100' -// -// >>> np.bitwise_xor(31, 5) -// 26 -// >>> np.bitwise_xor([31,3], 5) -// array([26, 6]) -// -// >>> np.bitwise_xor([31,3], [5,6]) -// array([26, 5]) -// >>> np.bitwise_xor([True, True], [False, True]) -// array([ True, False]) -// -// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on -// ndarrays. -// -// >>> x1 = np.array([True, True]) -// >>> x2 = np.array([False, True]) -// >>> x1 ^ x2 -// array([ True, False]) -// -//go:linkname BitwiseXor py.bitwise_xor -func BitwiseXor(__llgo_va_list ...interface{}) *py.Object -// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the cube-root of an array, element-wise. -// -// .. versionadded:: 1.10.0 -// -// Parameters -// ---------- -// x : array_like -// The values whose cube-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the cube -// cube-root of each element in `x`. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. -// -// -// Examples -// -------- -// >>> np.cbrt([1,8,27]) -// array([ 1., 2., 3.]) -// -//go:linkname Cbrt py.cbrt -func Cbrt(__llgo_va_list ...interface{}) *py.Object -// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the ceiling of the input, element-wise. -// -// The ceil of the scalar `x` is the smallest integer `i`, such that -// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The ceiling of each element in `x`, with `float` dtype. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// floor, trunc, rint, fix -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.ceil(a) -// array([-1., -1., -0., 1., 2., 2., 2.]) -// -//go:linkname Ceil py.ceil -func Ceil(__llgo_va_list ...interface{}) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the complex conjugate, element-wise. -// -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `conj` is an alias for `conjugate`: -// -// >>> np.conj is np.conjugate -// True -// -// Examples -// -------- -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conj py.conj -func Conj(__llgo_va_list ...interface{}) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the complex conjugate, element-wise. -// -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `conj` is an alias for `conjugate`: -// -// >>> np.conj is np.conjugate -// True -// -// Examples -// -------- -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conjugate py.conjugate -func Conjugate(__llgo_va_list ...interface{}) *py.Object -// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Change the sign of x1 to that of x2, element-wise. -// -// If `x2` is a scalar, its sign will be copied to all elements of `x1`. -// -// Parameters -// ---------- -// x1 : array_like -// Values to change the sign of. -// x2 : array_like -// The sign of `x2` is copied to `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The values of `x1` with the sign of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> np.copysign(1.3, -1) -// -1.3 -// >>> 1/np.copysign(0, 1) -// inf -// >>> 1/np.copysign(0, -1) -// -inf -// -// >>> np.copysign([-1, 0, 1], -1.1) -// array([-1., -0., -1.]) -// >>> np.copysign([-1, 0, 1], np.arange(3)-1) -// array([-1., 0., 1.]) -// -//go:linkname Copysign py.copysign -func Copysign(__llgo_va_list ...interface{}) *py.Object -// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Cosine element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding cosine values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. -// -// Examples -// -------- -// >>> np.cos(np.array([0, np.pi/2, np.pi])) -// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) -// >>> -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Cos py.cos -func Cos(__llgo_va_list ...interface{}) *py.Object -// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Hyperbolic cosine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array of same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.cosh(0) -// 1.0 -// -// The hyperbolic cosine describes the shape of a hanging cable: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-4, 4, 1000) -// >>> plt.plot(x, np.cosh(x)) -// >>> plt.show() -// -//go:linkname Cosh py.cosh -func Cosh(__llgo_va_list ...interface{}) *py.Object -// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from degrees to radians. -// -// Parameters -// ---------- -// x : array_like -// Angles in degrees. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in radians. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// rad2deg : Convert angles from radians to degrees. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// ``deg2rad(x)`` is ``x * pi / 180``. -// -// Examples -// -------- -// >>> np.deg2rad(180) -// 3.1415926535897931 -// -//go:linkname Deg2rad py.deg2rad -func Deg2rad(__llgo_va_list ...interface{}) *py.Object -// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray of floats -// The corresponding degree values; if `out` was supplied this is a -// reference to it. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// rad2deg : equivalent function -// -// Examples -// -------- -// Convert a radian array to degrees -// -// >>> rad = np.arange(12.)*np.pi/6 -// >>> np.degrees(rad) -// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., -// 270., 300., 330.]) -// -// >>> out = np.zeros((rad.shape)) -// >>> r = np.degrees(rad, out) -// >>> np.all(r == out) -// True -// -//go:linkname Degrees py.degrees -func Degrees(__llgo_va_list ...interface{}) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Divide arguments element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. -// -// Examples -// -------- -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.divide(x1, x2) -// array([[nan, 1. , 1. ], -// [inf, 4. , 2.5], -// [inf, 7. , 4. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) -// -//go:linkname Divide py.divide -func Divide(__llgo_va_list ...interface{}) *py.Object -// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return element-wise quotient and remainder simultaneously. -// -// .. versionadded:: 1.13.0 -// -// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster -// because it avoids redundant work. It is used to implement the Python -// built-in function ``divmod`` on NumPy arrays. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out1 : ndarray -// Element-wise quotient resulting from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// out2 : ndarray -// Element-wise remainder from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent to Python's ``//`` operator. -// remainder : Equivalent to Python's ``%`` operator. -// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return -// values switched. -// -// Examples -// -------- -// >>> np.divmod(np.arange(5), 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) -// -// The `divmod` function can be used as a shorthand for ``np.divmod`` on -// ndarrays. -// -// >>> x = np.arange(5) -// >>> divmod(x, 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) -// -//go:linkname Divmod py.divmod -func Divmod(__llgo_va_list ...interface{}) *py.Object -// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return (x1 == x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// not_equal, greater_equal, less_equal, greater, less -// -// Examples -// -------- -// >>> np.equal([0, 1, 3], np.arange(3)) -// array([ True, True, False]) -// -// What is compared are values, not types. So an int (1) and an array of -// length one can evaluate as True: -// -// >>> np.equal(1, np.ones(1)) -// array([ True]) -// -// The ``==`` operator can be used as a shorthand for ``np.equal`` on -// ndarrays. -// -// >>> a = np.array([2, 4, 6]) -// >>> b = np.array([2, 4, 2]) -// >>> a == b -// array([ True, True, False]) -// -//go:linkname Equal py.equal -func Equal(__llgo_va_list ...interface{}) *py.Object -// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the exponential of all elements in the input array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise exponential of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. -// exp2 : Calculate ``2**x`` for all elements in the array. -// -// Notes -// ----- -// The irrational number ``e`` is also known as Euler's number. It is -// approximately 2.718281, and is the base of the natural logarithm, -// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, -// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. -// -// For complex arguments, ``x = a + ib``, we can write -// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already -// known (it is the real argument, described above). The second term, -// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with -// magnitude 1 and a periodic phase. -// -// References -// ---------- -// .. [1] Wikipedia, "Exponential function", -// https://en.wikipedia.org/wiki/Exponential_function -// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions -// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, -// https://personal.math.ubc.ca/~cbm/aands/page_69.htm -// -// Examples -// -------- -// Plot the magnitude and phase of ``exp(x)`` in the complex plane: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) -// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane -// >>> out = np.exp(xx) -// -// >>> plt.subplot(121) -// >>> plt.imshow(np.abs(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') -// >>> plt.title('Magnitude of exp(x)') -// -// >>> plt.subplot(122) -// >>> plt.imshow(np.angle(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') -// >>> plt.title('Phase (angle) of exp(x)') -// >>> plt.show() -// -//go:linkname Exp py.exp -func Exp(__llgo_va_list ...interface{}) *py.Object -// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate `2**p` for all `p` in the input array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise 2 to the power `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// power -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// -// -// Examples -// -------- -// >>> np.exp2([2, 3]) -// array([ 4., 8.]) -// -//go:linkname Exp2 py.exp2 -func Exp2(__llgo_va_list ...interface{}) *py.Object -// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate ``exp(x) - 1`` for all elements in the array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise exponential minus one: ``out = exp(x) - 1``. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log1p : ``log(1 + x)``, the inverse of expm1. -// -// -// Notes -// ----- -// This function provides greater precision than ``exp(x) - 1`` -// for small values of ``x``. -// -// Examples -// -------- -// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to -// about 32 significant digits. This example shows the superiority of -// expm1 in this case. -// -// >>> np.expm1(1e-10) -// 1.00000000005e-10 -// >>> np.exp(1e-10) - 1 -// 1.000000082740371e-10 -// -//go:linkname Expm1 py.expm1 -func Expm1(__llgo_va_list ...interface{}) *py.Object -// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the absolute values element-wise. -// -// This function returns the absolute values (positive magnitude) of the -// data in `x`. Complex values are not handled, use `absolute` to find the -// absolute values of complex data. -// -// Parameters -// ---------- -// x : array_like -// The array of numbers for which the absolute values are required. If -// `x` is a scalar, the result `y` will also be a scalar. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The absolute values of `x`, the returned values are always floats. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// absolute : Absolute values including `complex` types. -// -// Examples -// -------- -// >>> np.fabs(-1) -// 1.0 -// >>> np.fabs([-1.2, 1.2]) -// array([ 1.2, 1.2]) -// -//go:linkname Fabs py.fabs -func Fabs(__llgo_va_list ...interface{}) *py.Object -// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the floor of the input, element-wise. -// -// The floor of the scalar `x` is the largest integer `i`, such that -// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The floor of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ceil, trunc, rint, fix -// -// Notes -// ----- -// Some spreadsheet programs calculate the "floor-towards-zero", where -// ``floor(-2.5) == -2``. NumPy instead uses the definition of -// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" -// function is called ``fix`` in NumPy. -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.floor(a) -// array([-2., -2., -1., 0., 1., 1., 2.]) -// -//go:linkname Floor py.floor -func Floor(__llgo_va_list ...interface{}) *py.Object -// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the largest integer smaller or equal to the division of the inputs. -// It is equivalent to the Python ``//`` operator and pairs with the -// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` -// up to roundoff. -// -// Parameters -// ---------- -// x1 : array_like -// Numerator. -// x2 : array_like -// Denominator. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// y = floor(`x1`/`x2`) -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// remainder : Remainder complementary to floor_divide. -// divmod : Simultaneous floor division and remainder. -// divide : Standard division. -// floor : Round a number to the nearest integer toward minus infinity. -// ceil : Round a number to the nearest integer toward infinity. -// -// Examples -// -------- -// >>> np.floor_divide(7,3) -// 2 -// >>> np.floor_divide([1., 2., 3., 4.], 2.5) -// array([ 0., 0., 1., 1.]) -// -// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` -// on ndarrays. -// -// >>> x1 = np.array([1., 2., 3., 4.]) -// >>> x1 // 2.5 -// array([0., 0., 1., 1.]) -// -//go:linkname FloorDivide py.floor_divide -func FloorDivide(__llgo_va_list ...interface{}) *py.Object -// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// First array elements raised to powers from second array, element-wise. -// -// Raise each base in `x1` to the positionally-corresponding power in `x2`. -// `x1` and `x2` must be broadcastable to the same shape. This differs from -// the power function in that integers, float16, and float32 are promoted to -// floats with a minimum precision of float64 so that the result is always -// inexact. The intent is that the function will return a usable result for -// negative powers and seldom overflow for positive powers. -// -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). -// -// .. versionadded:: 1.12.0 -// -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// power : power function that preserves type -// -// Examples -// -------- -// Cube each element in a list. -// -// >>> x1 = range(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.float_power(x1, 3) -// array([ 0., 1., 8., 27., 64., 125.]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.float_power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.float_power(x1, x2) -// array([[ 0., 1., 8., 27., 16., 5.], -// [ 0., 1., 8., 27., 16., 5.]]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1, -4]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.float_power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.float_power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname FloatPower py.float_power -func FloatPower(__llgo_va_list ...interface{}) *py.Object -// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise maximum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// minimum, amin, nanmin -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. -// -// Examples -// -------- -// >>> np.fmax([2, 3, 4], [1, 5, 2]) -// array([ 2., 5., 4.]) -// -// >>> np.fmax(np.eye(2), [0.5, 2]) -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) -// -// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) -// -//go:linkname Fmax py.fmax -func Fmax(__llgo_va_list ...interface{}) *py.Object -// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise minimum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. -// -// maximum, amax, nanmax -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. -// -// Examples -// -------- -// >>> np.fmin([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) -// -// >>> np.fmin(np.eye(2), [0.5, 2]) -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) -// -// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) -// -//go:linkname Fmin py.fmin -func Fmin(__llgo_va_list ...interface{}) *py.Object -// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// This is the NumPy implementation of the C library function fmod, the -// remainder has the same sign as the dividend `x1`. It is equivalent to -// the Matlab(TM) ``rem`` function and should not be confused with the -// Python modulus operator ``x1 % x2``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend. -// x2 : array_like -// Divisor. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : array_like -// The remainder of the division of `x1` by `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// remainder : Equivalent to the Python ``%`` operator. -// divide -// -// Notes -// ----- -// The result of the modulo operation for negative dividend and divisors -// is bound by conventions. For `fmod`, the sign of result is the sign of -// the dividend, while for `remainder` the sign of the result is the sign -// of the divisor. The `fmod` function is equivalent to the Matlab(TM) -// ``rem`` function. -// -// Examples -// -------- -// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) -// array([-1, 0, -1, 1, 0, 1]) -// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) -// array([1, 0, 1, 1, 0, 1]) -// -// >>> np.fmod([5, 3], [2, 2.]) -// array([ 1., 1.]) -// >>> a = np.arange(-3, 3).reshape(3, 2) -// >>> a -// array([[-3, -2], -// [-1, 0], -// [ 1, 2]]) -// >>> np.fmod(a, [2,2]) -// array([[-1, 0], -// [-1, 0], -// [ 1, 0]]) -// -//go:linkname Fmod py.fmod -func Fmod(__llgo_va_list ...interface{}) *py.Object -// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Decompose the elements of x into mantissa and twos exponent. -// -// Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``. -// The mantissa lies in the open interval(-1, 1), while the twos -// exponent is a signed integer. -// -// Parameters -// ---------- -// x : array_like -// Array of numbers to be decomposed. -// out1 : ndarray, optional -// Output array for the mantissa. Must have the same shape as `x`. -// out2 : ndarray, optional -// Output array for the exponent. Must have the same shape as `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// mantissa : ndarray -// Floating values between -1 and 1. -// This is a scalar if `x` is a scalar. -// exponent : ndarray -// Integer exponents of 2. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`. -// -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. -// -// Examples -// -------- -// >>> x = np.arange(9) -// >>> y1, y2 = np.frexp(x) -// >>> y1 -// array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, -// 0.5 ]) -// >>> y2 -// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) -// >>> y1 * 2**y2 -// array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) -// -//go:linkname Frexp py.frexp -func Frexp(__llgo_va_list ...interface{}) *py.Object -// gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the greatest common divisor of ``|x1|`` and ``|x2|`` -// -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The greatest common divisor of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// lcm : The lowest common multiple -// -// Examples -// -------- -// >>> np.gcd(12, 20) -// 4 -// >>> np.gcd.reduce([15, 25, 35]) -// 5 -// >>> np.gcd(np.arange(6), 20) -// array([20, 1, 2, 1, 4, 5]) -// -//go:linkname Gcd py.gcd -func Gcd(__llgo_va_list ...interface{}) *py.Object -// greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 > x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// -// See Also -// -------- -// greater_equal, less, less_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.greater([4,2],[2,2]) -// array([ True, False]) -// -// The ``>`` operator can be used as a shorthand for ``np.greater`` on -// ndarrays. -// -// >>> a = np.array([4, 2]) -// >>> b = np.array([2, 2]) -// >>> a > b -// array([ True, False]) -// -//go:linkname Greater py.greater -func Greater(__llgo_va_list ...interface{}) *py.Object -// greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 >= x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : bool or ndarray of bool -// 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. -// -// See Also -// -------- -// greater, less, less_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.greater_equal([4, 2, 1], [2, 2, 2]) -// array([ True, True, False]) -// -// The ``>=`` operator can be used as a shorthand for ``np.greater_equal`` -// on ndarrays. -// -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a >= b -// array([ True, True, False]) -// -//go:linkname GreaterEqual py.greater_equal -func GreaterEqual(__llgo_va_list ...interface{}) *py.Object -// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the Heaviside step function. -// -// The Heaviside step function is defined as:: -// -// 0 if x1 < 0 -// heaviside(x1, x2) = x2 if x1 == 0 -// 1 if x1 > 0 -// -// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. -// -// Parameters -// ---------- -// x1 : array_like -// Input values. -// x2 : array_like -// The value of the function when x1 is 0. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The output array, element-wise Heaviside step function of `x1`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// .. versionadded:: 1.13.0 -// -// References -// ---------- -// .. Wikipedia, "Heaviside step function", -// https://en.wikipedia.org/wiki/Heaviside_step_function -// -// Examples -// -------- -// >>> np.heaviside([-1.5, 0, 2.0], 0.5) -// array([ 0. , 0.5, 1. ]) -// >>> np.heaviside([-1.5, 0, 2.0], 1) -// array([ 0., 1., 1.]) -// -//go:linkname Heaviside py.heaviside -func Heaviside(__llgo_va_list ...interface{}) *py.Object -// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Given the "legs" of a right triangle, return its hypotenuse. -// -// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. 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. -// (See Examples) -// -// Parameters -// ---------- -// x1, x2 : array_like -// Leg of the triangle(s). -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// z : ndarray -// The hypotenuse of the triangle(s). -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) -// -// Example showing broadcast of scalar_like argument: -// -// >>> np.hypot(3*np.ones((3, 3)), [4]) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) -// -//go:linkname Hypot py.hypot -func Hypot(__llgo_va_list ...interface{}) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute bit-wise inversion, or bit-wise NOT, element-wise. -// -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. -// -// For signed integer inputs, the two's complement is returned. In a -// two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit -// two's-complement system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Notes -// ----- -// `bitwise_not` is an alias for `invert`: -// -// >>> np.bitwise_not is np.invert -// True -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: -// -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// 242 -// >>> np.binary_repr(x, width=8) -// '11110010' -// -// The result depends on the bit-width: -// -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// 65522 -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types the result is the two's complement of -// the result for the unsigned type: -// -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' -// -// Booleans are accepted as well: -// -// >>> np.invert(np.array([True, False])) -// array([False, True]) -// -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. -// -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) -// -//go:linkname Invert py.invert -func Invert(__llgo_va_list ...interface{}) *py.Object -// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for finiteness (not infinity and not Not a Number). -// -// The result is returned as a boolean array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray, bool -// True where ``x`` is not positive infinity, negative infinity, -// or NaN; false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isinf, isneginf, isposinf, isnan -// -// 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. -// -// Examples -// -------- -// >>> np.isfinite(1) -// True -// >>> np.isfinite(0) -// True -// >>> np.isfinite(np.nan) -// False -// >>> np.isfinite(np.inf) -// False -// >>> np.isfinite(np.NINF) -// False -// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) -// array([False, True, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isfinite(x, y) -// array([0, 1, 0]) -// >>> y -// array([0, 1, 0]) -// -//go:linkname Isfinite py.isfinite -func Isfinite(__llgo_va_list ...interface{}) *py.Object -// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for positive or negative infinity. -// -// Returns a boolean array of the same shape as `x`, True where ``x == -// +/-inf``, otherwise False. -// -// Parameters -// ---------- -// x : array_like -// Input values -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool (scalar) or boolean ndarray -// True where ``x`` is positive or negative infinity, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isneginf, isposinf, isnan, isfinite -// -// 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. -// -// Examples -// -------- -// >>> np.isinf(np.inf) -// True -// >>> np.isinf(np.nan) -// False -// >>> np.isinf(np.NINF) -// True -// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) -// array([ True, True, False, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isinf(x, y) -// array([1, 0, 1]) -// >>> y -// array([1, 0, 1]) -// -//go:linkname Isinf py.isinf -func Isinf(__llgo_va_list ...interface{}) *py.Object -// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for NaN and return result as a boolean array. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaN, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isinf, isneginf, isposinf, isfinite, isnat -// -// 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. -// -// Examples -// -------- -// >>> np.isnan(np.nan) -// True -// >>> np.isnan(np.inf) -// False -// >>> np.isnan([np.log(-1.),1.,np.log(0)]) -// array([ True, False, False]) -// -//go:linkname Isnan py.isnan -func Isnan(__llgo_va_list ...interface{}) *py.Object -// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for NaT (not a time) and return result as a boolean array. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// x : array_like -// Input array with datetime or timedelta data type. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaT, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isnan, isinf, isneginf, isposinf, isfinite -// -// Examples -// -------- -// >>> np.isnat(np.datetime64("NaT")) -// True -// >>> np.isnat(np.datetime64("2016-01-01")) -// False -// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) -// array([ True, False]) -// -//go:linkname Isnat py.isnat -func Isnat(__llgo_va_list ...interface{}) *py.Object -// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` -// -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The lowest common multiple of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// gcd : The greatest common divisor -// -// Examples -// -------- -// >>> np.lcm(12, 20) -// 60 -// >>> np.lcm.reduce([3, 12, 20]) -// 60 -// >>> np.lcm.reduce([40, 12, 20]) -// 120 -// >>> np.lcm(np.arange(6), 20) -// array([ 0, 20, 20, 60, 20, 20]) -// -//go:linkname Lcm py.lcm -func Lcm(__llgo_va_list ...interface{}) *py.Object -// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns x1 * 2**x2, element-wise. -// -// The mantissas `x1` and twos exponents `x2` are used to construct -// floating point numbers ``x1 * 2**x2``. -// -// Parameters -// ---------- -// x1 : array_like -// Array of multipliers. -// x2 : array_like, int -// Array of twos exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The result of ``x1 * 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. -// -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. -// -// `ldexp` is useful as the inverse of `frexp`, if used by itself it is -// more clear to simply use the expression ``x1 * 2**x2``. -// -// Examples -// -------- -// >>> np.ldexp(5, np.arange(4)) -// array([ 5., 10., 20., 40.], dtype=float16) -// -// >>> x = np.arange(6) -// >>> np.ldexp(*np.frexp(x)) -// array([ 0., 1., 2., 3., 4., 5.]) -// -//go:linkname Ldexp py.ldexp -func Ldexp(__llgo_va_list ...interface{}) *py.Object -// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Shift the bits of an integer to the left. -// -// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. -// Since the internal representation of numbers is in binary format, this -// operation is equivalent to multiplying `x1` by ``2**x2``. -// -// Parameters -// ---------- -// x1 : array_like of integer type -// Input values. -// x2 : array_like of integer type -// Number of zeros to append to `x1`. Has to be non-negative. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : array of integer type -// Return `x1` with bits shifted `x2` times to the left. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// right_shift : Shift the bits of an integer to the right. -// binary_repr : Return the binary representation of the input number -// as a string. -// -// Examples -// -------- -// >>> np.binary_repr(5) -// '101' -// >>> np.left_shift(5, 2) -// 20 -// >>> np.binary_repr(20) -// '10100' -// -// >>> np.left_shift(5, [1,2,3]) -// array([10, 20, 40]) -// -// Note that the dtype of the second argument may change the dtype of the -// result and can lead to unexpected results in some cases (see -// :ref:`Casting Rules `): -// -// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 -// >>> print(a, type(a)) # Unexpected result due to upcasting -// 510 -// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) -// >>> print(b, type(b)) -// 254 -// -// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on -// ndarrays. -// -// >>> x1 = 5 -// >>> x2 = np.array([1, 2, 3]) -// >>> x1 << x2 -// array([10, 20, 40]) -// -//go:linkname LeftShift py.left_shift -func LeftShift(__llgo_va_list ...interface{}) *py.Object -// less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 < x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// greater, less_equal, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.less([1, 2], [2, 2]) -// array([ True, False]) -// -// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. -// -// >>> a = np.array([1, 2]) -// >>> b = np.array([2, 2]) -// >>> a < b -// array([ True, False]) -// -//go:linkname Less py.less -func Less(__llgo_va_list ...interface{}) *py.Object -// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 <= x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// greater, less, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.less_equal([4, 2, 1], [2, 2, 2]) -// array([False, True, True]) -// -// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on -// ndarrays. -// -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a <= b -// array([False, True, True]) -// -//go:linkname LessEqual py.less_equal -func LessEqual(__llgo_va_list ...interface{}) *py.Object -// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Natural logarithm, element-wise. -// -// The natural logarithm `log` is the inverse of the exponential function, -// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base -// `e`. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The natural logarithm of `x`, element-wise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log10, log2, log1p, emath.log -// -// Notes -// ----- -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `exp(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log` always returns real output. For -// each value that cannot be expressed as a real number or infinity, it -// yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. `log` -// handles the floating-point negative zero as an infinitesimal negative -// number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log([1, np.e, np.e**2, 0]) -// array([ 0., 1., 2., -Inf]) -// -//go:linkname Log py.log -func Log(__llgo_va_list ...interface{}) *py.Object -// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the base 10 logarithm of the input array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The logarithm to the base 10 of `x`, element-wise. NaNs are -// returned where x is negative. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.log10 -// -// Notes -// ----- -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `10**z = x`. The convention is to return the -// `z` whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log10` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log10` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. -// `log10` handles the floating-point negative zero as an infinitesimal -// negative number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log10([1e-15, -3.]) -// array([-15., nan]) -// -//go:linkname Log10 py.log10 -func Log10(__llgo_va_list ...interface{}) *py.Object -// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the natural logarithm of one plus the input array, element-wise. -// -// Calculates ``log(1 + x)``. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Natural logarithm of `1 + x`, element-wise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// expm1 : ``exp(x) - 1``, the inverse of `log1p`. -// -// Notes -// ----- -// For real-valued input, `log1p` is accurate also for `x` so small -// that `1 + x == 1` in floating-point accuracy. -// -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `exp(z) = 1 + x`. The convention is to return -// the `z` whose imaginary part lies in `[-pi, pi]`. -// -// For real-valued input data types, `log1p` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log1p` is a complex analytical function that -// has a branch cut `[-inf, -1]` and is continuous from above on it. -// `log1p` handles the floating-point negative zero as an infinitesimal -// negative number, conforming to the C99 standard. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log1p(1e-99) -// 1e-99 -// >>> np.log(1 + 1e-99) -// 0.0 -// -//go:linkname Log1p py.log1p -func Log1p(__llgo_va_list ...interface{}) *py.Object -// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Base-2 logarithm of `x`. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Base-2 logarithm of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log, log10, log1p, emath.log2 -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `2**z = x`. The convention is to return the `z` -// whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log2` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log2` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` -// handles the floating-point negative zero as an infinitesimal negative -// number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// Examples -// -------- -// >>> x = np.array([0, 1, 2, 2**4]) -// >>> np.log2(x) -// array([-Inf, 0., 1., 4.]) -// -// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) -// >>> np.log2(xi) -// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) -// -//go:linkname Log2 py.log2 -func Log2(__llgo_va_list ...interface{}) *py.Object -// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Logarithm of the sum of exponentiations of the inputs. -// -// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in -// statistics where the calculated probabilities of events may be so small -// as to exceed the range of normal floating point numbers. In such cases -// the logarithm of the calculated probability is stored. This function -// allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Logarithm of ``exp(x1) + exp(x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> prob1 = np.log(1e-50) -// >>> prob2 = np.log(2.5e-50) -// >>> prob12 = np.logaddexp(prob1, prob2) -// >>> prob12 -// -113.87649168120691 -// >>> np.exp(prob12) -// 3.5000000000000057e-50 -// -//go:linkname Logaddexp py.logaddexp -func Logaddexp(__llgo_va_list ...interface{}) *py.Object -// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Logarithm of the sum of exponentiations of the inputs in base-2. -// -// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine -// learning when the calculated probabilities of events may be so small as -// to exceed the range of normal floating point numbers. In such cases -// the base-2 logarithm of the calculated probability can be used instead. -// This function allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Base-2 logarithm of ``2**x1 + 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp: Logarithm of the sum of exponentiations of the inputs. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> prob1 = np.log2(1e-50) -// >>> prob2 = np.log2(2.5e-50) -// >>> prob12 = np.logaddexp2(prob1, prob2) -// >>> prob1, prob2, prob12 -// (-166.09640474436813, -164.77447664948076, -164.28904982231052) -// >>> 2**prob12 -// 3.4999999999999914e-50 -// -//go:linkname Logaddexp2 py.logaddexp2 -func Logaddexp2(__llgo_va_list ...interface{}) *py.Object -// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 AND x2 element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical AND operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_or, logical_not, logical_xor -// bitwise_and -// -// Examples -// -------- -// >>> np.logical_and(True, False) -// False -// >>> np.logical_and([True, False], [False, False]) -// array([False, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_and(x>1, x<4) -// array([False, False, True, True, False]) -// -// -// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on -// boolean ndarrays. -// -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a & b -// array([False, False]) -// -//go:linkname LogicalAnd py.logical_and -func LogicalAnd(__llgo_va_list ...interface{}) *py.Object -// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of NOT x element-wise. -// -// Parameters -// ---------- -// x : array_like -// Logical NOT is applied to the elements of `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool or ndarray of bool -// 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. -// -// See Also -// -------- -// logical_and, logical_or, logical_xor -// -// Examples -// -------- -// >>> np.logical_not(3) -// False -// >>> np.logical_not([True, False, 0, 1]) -// array([False, True, True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_not(x<3) -// array([False, False, False, True, True]) -// -//go:linkname LogicalNot py.logical_not -func LogicalNot(__llgo_va_list ...interface{}) *py.Object -// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 OR x2 element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Logical OR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical OR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and, logical_not, logical_xor -// bitwise_or -// -// Examples -// -------- -// >>> np.logical_or(True, False) -// True -// >>> np.logical_or([True, False], [False, False]) -// array([ True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_or(x < 1, x > 3) -// array([ True, False, False, False, True]) -// -// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on -// boolean ndarrays. -// -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a | b -// array([ True, False]) -// -//go:linkname LogicalOr py.logical_or -func LogicalOr(__llgo_va_list ...interface{}) *py.Object -// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 XOR x2, element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Logical XOR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool or ndarray of bool -// Boolean result of the logical XOR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and, logical_or, logical_not, bitwise_xor -// -// Examples -// -------- -// >>> np.logical_xor(True, False) -// True -// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) -// array([False, True, True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_xor(x < 1, x > 3) -// array([ True, False, False, False, True]) -// -// Simple example showing support of broadcasting -// -// >>> np.logical_xor(0, np.eye(2)) -// array([[ True, False], -// [False, True]]) -// -//go:linkname LogicalXor py.logical_xor -func LogicalXor(__llgo_va_list ...interface{}) *py.Object -// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise maximum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// fmin, amin, nanmin -// -// Notes -// ----- -// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when -// neither x1 nor x2 are nans, but it is faster and does proper -// broadcasting. -// -// Examples -// -------- -// >>> np.maximum([2, 3, 4], [1, 5, 2]) -// array([2, 5, 4]) -// -// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) -// -// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.maximum(np.Inf, 1) -// inf -// -//go:linkname Maximum py.maximum -func Maximum(__llgo_va_list ...interface{}) *py.Object -// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise minimum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. -// -// fmax, amax, nanmax -// -// Notes -// ----- -// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when -// neither x1 nor x2 are NaNs, but it is faster and does proper -// broadcasting. -// -// Examples -// -------- -// >>> np.minimum([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) -// -// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) -// -// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.minimum(-np.Inf, 1) -// -inf -// -//go:linkname Minimum py.minimum -func Minimum(__llgo_va_list ...interface{}) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. -// -// .. warning:: -// -// This should not be confused with: -// -// * Python 3.7's `math.remainder` and C's ``remainder``, which -// computes the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor -// -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. -// -// Examples -// -------- -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) -// -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. -// -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) -// -//go:linkname Mod py.mod -func Mod(__llgo_va_list ...interface{}) *py.Object -// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the fractional and integral parts of an array, element-wise. -// -// The fractional and integral parts are negative if the given number is -// negative. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y1 : ndarray -// Fractional part of `x`. -// This is a scalar if `x` is a scalar. -// y2 : ndarray -// Integral part of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// For integer input the return values are floats. -// -// See Also -// -------- -// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values -// switched, except it always has a positive remainder. -// -// Examples -// -------- -// >>> np.modf([0, 3.5]) -// (array([ 0. , 0.5]), array([ 0., 3.])) -// >>> np.modf(-0.5) -// (-0.5, -0) -// -//go:linkname Modf py.modf -func Modf(__llgo_va_list ...interface{}) *py.Object -// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Multiply arguments element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays to be multiplied. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The product of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to `x1` * `x2` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.multiply(2.0, 4.0) -// 8.0 -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.multiply(x1, x2) -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) -// -// The ``*`` operator can be used as a shorthand for ``np.multiply`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 * x2 -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) -// -//go:linkname Multiply py.multiply -func Multiply(__llgo_va_list ...interface{}) *py.Object -// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Numerical negative, element-wise. -// -// Parameters -// ---------- -// x : array_like or scalar -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// Returned array or scalar: `y = -x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.negative([1.,-1.]) -// array([-1., 1.]) -// -// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> -x1 -// array([-1., 1.]) -// -//go:linkname Negative py.negative -func Negative(__llgo_va_list ...interface{}) *py.Object -// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the next floating-point value after x1 towards x2, element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Values to find the next representable value of. -// x2 : array_like -// The direction where to look for the next representable value of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The next representable values of `x1` in the direction of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> eps = np.finfo(np.float64).eps -// >>> np.nextafter(1, 2) == eps + 1 -// True -// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] -// array([ True, True]) -// -//go:linkname Nextafter py.nextafter -func Nextafter(__llgo_va_list ...interface{}) *py.Object -// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return (x1 != x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// equal, greater, greater_equal, less, less_equal -// -// Examples -// -------- -// >>> np.not_equal([1.,2.], [1., 3.]) -// array([False, True]) -// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) -// array([[False, True], -// [False, True]]) -// -// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on -// ndarrays. -// -// >>> a = np.array([1., 2.]) -// >>> b = np.array([1., 3.]) -// >>> a != b -// array([False, True]) -// -//go:linkname NotEqual py.not_equal -func NotEqual(__llgo_va_list ...interface{}) *py.Object -// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Numerical positive, element-wise. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// x : array_like or scalar -// Input array. -// -// Returns -// ------- -// y : ndarray or scalar -// Returned array or scalar: `y = +x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// Equivalent to `x.copy()`, but only defined for types that support -// arithmetic. -// -// Examples -// -------- -// -// >>> x1 = np.array(([1., -1.])) -// >>> np.positive(x1) -// array([ 1., -1.]) -// -// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> +x1 -// array([ 1., -1.]) -// -//go:linkname Positive py.positive -func Positive(__llgo_va_list ...interface{}) *py.Object -// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// First array elements raised to powers from second array, element-wise. -// -// Raise each base in `x1` to the positionally-corresponding power in -// `x2`. `x1` and `x2` must be broadcastable to the same shape. -// -// An integer type raised to a negative integer power will raise a -// ``ValueError``. -// -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). -// -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// float_power : power function that promotes integers to float -// -// Examples -// -------- -// Cube each element in an array. -// -// >>> x1 = np.arange(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.power(x1, 3) -// array([ 0, 1, 8, 27, 64, 125]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.power(x1, x2) -// array([[ 0, 1, 8, 27, 16, 5], -// [ 0, 1, 8, 27, 16, 5]]) -// -// The ``**`` operator can be used as a shorthand for ``np.power`` on -// ndarrays. -// -// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) -// >>> x1 = np.arange(6) -// >>> x1 ** x2 -// array([ 0, 1, 8, 27, 16, 5]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1.0, -4.0]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname Power py.power -func Power(__llgo_va_list ...interface{}) *py.Object -// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Angle in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in degrees. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : Convert angles from degrees to radians. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// rad2deg(x) is ``180 * x / pi``. -// -// Examples -// -------- -// >>> np.rad2deg(np.pi/2) -// 90.0 -// -//go:linkname Rad2deg py.rad2deg -func Rad2deg(__llgo_va_list ...interface{}) *py.Object -// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from degrees to radians. -// -// Parameters -// ---------- -// x : array_like -// Input array in degrees. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding radian values. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : equivalent function -// -// Examples -// -------- -// Convert a degree array to radians -// -// >>> deg = np.arange(12.) * 30. -// >>> np.radians(deg) -// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , -// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, -// 5.23598776, 5.75958653]) -// -// >>> out = np.zeros((deg.shape)) -// >>> ret = np.radians(deg, out) -// >>> ret is out -// True -// -//go:linkname Radians py.radians -func Radians(__llgo_va_list ...interface{}) *py.Object -// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the reciprocal of the argument, element-wise. -// -// Calculates ``1/x``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Return array. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// .. note:: -// This function is not designed to work with integers. -// -// For integer arguments with absolute value larger than 1 the result is -// always zero because of the way Python handles integer division. For -// integer zero the result is an overflow. -// -// Examples -// -------- -// >>> np.reciprocal(2.) -// 0.5 -// >>> np.reciprocal([1, 2., 3.33]) -// array([ 1. , 0.5 , 0.3003003]) -// -//go:linkname Reciprocal py.reciprocal -func Reciprocal(__llgo_va_list ...interface{}) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. -// -// .. warning:: -// -// This should not be confused with: -// -// * Python 3.7's `math.remainder` and C's ``remainder``, which -// computes the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor -// -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. -// -// Examples -// -------- -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) -// -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. -// -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) -// -//go:linkname Remainder py.remainder -func Remainder(__llgo_va_list ...interface{}) *py.Object -// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Shift the bits of an integer to the right. -// -// Bits are shifted to the right `x2`. Because the internal -// representation of numbers is in binary format, this operation is -// equivalent to dividing `x1` by ``2**x2``. -// -// Parameters -// ---------- -// x1 : array_like, int -// Input values. -// x2 : array_like, int -// Number of bits to remove at the right of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray, int -// Return `x1` with bits shifted `x2` times to the right. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// left_shift : Shift the bits of an integer to the left. -// binary_repr : Return the binary representation of the input number -// as a string. -// -// Examples -// -------- -// >>> np.binary_repr(10) -// '1010' -// >>> np.right_shift(10, 1) -// 5 -// >>> np.binary_repr(5) -// '101' -// -// >>> np.right_shift(10, [1,2,3]) -// array([5, 2, 1]) -// -// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on -// ndarrays. -// -// >>> x1 = 10 -// >>> x2 = np.array([1,2,3]) -// >>> x1 >> x2 -// array([5, 2, 1]) -// -//go:linkname RightShift py.right_shift -func RightShift(__llgo_va_list ...interface{}) *py.Object -// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Round elements of the array to the nearest integer. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array is same shape and type as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// fix, ceil, floor, trunc -// -// Notes -// ----- -// For values exactly halfway between rounded decimal values, NumPy -// rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, -// -0.5 and 0.5 round to 0.0, etc. -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.rint(a) -// array([-2., -2., -0., 0., 2., 2., 2.]) -// -//go:linkname Rint py.rint -func Rint(__llgo_va_list ...interface{}) *py.Object -// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns an element-wise indication of the sign of a number. -// -// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan -// is returned for nan inputs. -// -// For complex inputs, the `sign` function returns -// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. -// -// complex(nan, 0) is returned for complex nan inputs. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The sign of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// There is more than one definition of sign in common use for complex -// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` -// which is different from a common alternative, :math:`x/|x|`. -// -// Examples -// -------- -// >>> np.sign([-5., 4.5]) -// array([-1., 1.]) -// >>> np.sign(0) -// 0 -// >>> np.sign(5-2j) -// (1+0j) -// -//go:linkname Sign py.sign -func Sign(__llgo_va_list ...interface{}) *py.Object -// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns element-wise True where signbit is set (less than zero). -// -// Parameters -// ---------- -// x : array_like -// The input value(s). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray of bool -// Output array, or reference to `out` if that was supplied. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.signbit(-1.2) -// True -// >>> np.signbit(np.array([1, -2.3, 2.1])) -// array([False, True, False]) -// -//go:linkname Signbit py.signbit -func Signbit(__llgo_va_list ...interface{}) *py.Object -// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric sine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : array_like -// The sine of each element of x. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// arcsin, sinh, cos -// -// Notes -// ----- -// The sine is one of the fundamental functions of trigonometry (the -// mathematical study of triangles). Consider a circle of radius 1 -// centered on the origin. A ray comes in from the :math:`+x` axis, makes -// an angle at the origin (measured counter-clockwise from that axis), and -// departs from the origin. The :math:`y` coordinate of the outgoing -// ray's intersection with the unit circle is the sine of that angle. It -// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The -// function has zeroes where the angle is a multiple of :math:`\pi`. -// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. -// The numerous properties of the sine and related functions are included -// in any standard trigonometry text. -// -// Examples -// -------- -// Print sine of one angle: -// -// >>> np.sin(np.pi/2.) -// 1.0 -// -// Print sines of an array of angles given in degrees: -// -// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) -// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) -// -// Plot the sine function: -// -// >>> import matplotlib.pylab as plt -// >>> x = np.linspace(-np.pi, np.pi, 201) -// >>> plt.plot(x, np.sin(x)) -// >>> plt.xlabel('Angle [rad]') -// >>> plt.ylabel('sin(x)') -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Sin py.sin -func Sin(__llgo_va_list ...interface{}) *py.Object -// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Hyperbolic sine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or -// ``-1j * np.sin(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding hyperbolic sine values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// -// Examples -// -------- -// >>> np.sinh(0) -// 0.0 -// >>> np.sinh(np.pi*1j/2) -// 1j -// >>> np.sinh(np.pi*1j) # (exact value is 0) -// 1.2246063538223773e-016j -// >>> # Discrepancy due to vagaries of floating point arithmetic. -// -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.sinh([0.1], out1) -// >>> out2 is out1 -// True -// -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Sinh py.sinh -func Sinh(__llgo_va_list ...interface{}) *py.Object -// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the distance between x and the nearest adjacent number. -// -// Parameters -// ---------- -// x : array_like -// Values to find the spacing of. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The spacing of values of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// It can be considered as a generalization of EPS: -// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there -// should not be any representable number between ``x + spacing(x)`` and -// x for any finite x. -// -// Spacing of +- inf and NaN is NaN. -// -// Examples -// -------- -// >>> np.spacing(1) == np.finfo(np.float64).eps -// True -// -//go:linkname Spacing py.spacing -func Spacing(__llgo_va_list ...interface{}) *py.Object -// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the non-negative square-root of an array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// The values whose square-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the positive -// square-root of each element in `x`. If any element in `x` is -// complex, a complex array is returned (and the square-roots of -// negative reals are calculated). If all of the elements in `x` -// are real, so is `y`, with negative elements returning ``nan``. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.sqrt -// A version which returns complex numbers when given negative reals. -// Note that 0.0 and -0.0 are handled differently for complex inputs. -// -// Notes -// ----- -// *sqrt* has--consistent with common convention--as its branch cut the -// real "interval" [`-inf`, 0), and is continuous from above on it. -// A branch cut is a curve in the complex plane across which a given -// complex function fails to be continuous. -// -// Examples -// -------- -// >>> np.sqrt([1,4,9]) -// array([ 1., 2., 3.]) -// -// >>> np.sqrt([4, -1, -3+4J]) -// array([ 2.+0.j, 0.+1.j, 1.+2.j]) -// -// >>> np.sqrt([4, -1, np.inf]) -// array([ 2., nan, inf]) -// -//go:linkname Sqrt py.sqrt -func Sqrt(__llgo_va_list ...interface{}) *py.Object -// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the element-wise square of the input. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise `x*x`, of the same shape and dtype as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// numpy.linalg.matrix_power -// sqrt -// power -// -// Examples -// -------- -// >>> np.square([-1j, 1]) -// array([-1.-0.j, 1.+0.j]) -// -//go:linkname Square py.square -func Square(__llgo_va_list ...interface{}) *py.Object -// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Subtract arguments, element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays to be subtracted from each other. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The difference of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to ``x1 - x2`` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.subtract(1.0, 4.0) -// -3.0 -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.subtract(x1, x2) -// array([[ 0., 0., 0.], -// [ 3., 3., 3.], -// [ 6., 6., 6.]]) -// -// The ``-`` operator can be used as a shorthand for ``np.subtract`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 - x2 -// array([[0., 0., 0.], -// [3., 3., 3.], -// [6., 6., 6.]]) -// -//go:linkname Subtract py.subtract -func Subtract(__llgo_va_list ...interface{}) *py.Object -// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute tangent element-wise. -// -// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding tangent values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. -// -// Examples -// -------- -// >>> from math import pi -// >>> np.tan(np.array([-pi,pi/2,pi])) -// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) -// >>> -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Tan py.tan -func Tan(__llgo_va_list ...interface{}) *py.Object -// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute hyperbolic tangent element-wise. -// -// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding hyperbolic tangent values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// https://personal.math.ubc.ca/~cbm/aands/page_83.htm -// -// .. [2] Wikipedia, "Hyperbolic function", -// https://en.wikipedia.org/wiki/Hyperbolic_function -// -// Examples -// -------- -// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) -// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) -// -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.tanh([0.1], out1) -// >>> out2 is out1 -// True -// -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Tanh py.tanh -func Tanh(__llgo_va_list ...interface{}) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Divide arguments element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. -// -// Examples -// -------- -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.divide(x1, x2) -// array([[nan, 1. , 1. ], -// [inf, 4. , 2.5], -// [inf, 7. , 4. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) -// -//go:linkname TrueDivide py.true_divide -func TrueDivide(__llgo_va_list ...interface{}) *py.Object -// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truncated value of the input, element-wise. -// -// The truncated value of the scalar `x` is the nearest integer `i` which -// is closer to zero than `x` is. In short, the fractional part of the -// signed number `x` is discarded. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The truncated value of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ceil, floor, rint, fix -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.trunc(a) -// array([-1., -1., -0., 0., 1., 1., 2.]) -// -//go:linkname Trunc py.trunc -func Trunc(__llgo_va_list ...interface{}) *py.Object -// -// Return the scalar dtype or NumPy equivalent of Python type of an object. -// -// Parameters -// ---------- -// rep : any -// The object of which the type is returned. -// default : any, optional -// If given, this is returned for objects whose types can not be -// determined. If not given, None is returned for those objects. -// -// Returns -// ------- -// dtype : dtype or Python type -// The data type of `rep`. -// -// See Also -// -------- -// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype -// -// Examples -// -------- -// >>> np.obj2sctype(np.int32) -// -// >>> np.obj2sctype(np.array([1., 2.])) -// -// >>> np.obj2sctype(np.array([1.j])) -// -// -// >>> np.obj2sctype(dict) -// -// >>> np.obj2sctype('string') -// -// >>> np.obj2sctype(1, default=list) -// -// -// -// -//go:linkname Obj2sctype py.obj2sctype -func Obj2sctype(rep *py.Object, default_ *py.Object) *py.Object -// -// Return the string representation of a scalar dtype. -// -// Parameters -// ---------- -// sctype : scalar dtype or object -// If a scalar dtype, the corresponding string character is -// returned. If an object, `sctype2char` tries to infer its scalar type -// and then return the corresponding string character. -// -// Returns -// ------- -// typechar : str -// The string character corresponding to the scalar type. -// -// Raises -// ------ -// ValueError -// If `sctype` is an object for which the type can not be inferred. -// -// See Also -// -------- -// obj2sctype, issctype, issubsctype, mintypecode -// -// Examples -// -------- -// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: -// ... print(np.sctype2char(sctype)) -// l # may vary -// d -// D -// S -// O -// -// >>> x = np.array([1., 2-1.j]) -// >>> np.sctype2char(x) -// 'D' -// >>> np.sctype2char(list) -// 'O' -// -// -// -//go:linkname Sctype2char py.sctype2char -func Sctype2char(sctype *py.Object) *py.Object -// -// Return the scalar type of highest precision of the same kind as the input. -// -// Parameters -// ---------- -// t : dtype or dtype specifier -// The input data type. This can be a `dtype` object or an object that -// is convertible to a `dtype`. -// -// Returns -// ------- -// out : dtype -// The highest precision data type of the same kind (`dtype.kind`) as `t`. -// -// See Also -// -------- -// obj2sctype, mintypecode, sctype2char -// dtype -// -// Examples -// -------- -// >>> np.maximum_sctype(int) -// -// >>> np.maximum_sctype(np.uint8) -// -// >>> np.maximum_sctype(complex) -// # may vary -// -// >>> np.maximum_sctype(str) -// -// -// >>> np.maximum_sctype('i2') -// -// >>> np.maximum_sctype('f4') -// # may vary -// -// -// -//go:linkname MaximumSctype py.maximum_sctype -func MaximumSctype(t *py.Object) *py.Object -// -// Determines whether the given object represents a scalar data-type. -// -// Parameters -// ---------- -// rep : any -// If `rep` is an instance of a scalar dtype, True is returned. If not, -// False is returned. -// -// Returns -// ------- -// out : bool -// Boolean result of check whether `rep` is a scalar dtype. -// -// See Also -// -------- -// issubsctype, issubdtype, obj2sctype, sctype2char -// -// Examples -// -------- -// >>> np.issctype(np.int32) -// True -// >>> np.issctype(list) -// False -// >>> np.issctype(1.1) -// False -// -// Strings are also a scalar type: -// -// >>> np.issctype(np.dtype('str')) -// True -// -// -// -//go:linkname Issctype py.issctype -func Issctype(rep *py.Object) *py.Object -// -// Determine common type following standard coercion rules. -// -// .. deprecated:: NumPy 1.25 -// -// This function is deprecated, use `numpy.promote_types` or -// `numpy.result_type` instead. To achieve semantics for the -// `scalar_types` argument, use `numpy.result_type` and pass the Python -// values `0`, `0.0`, or `0j`. -// This will give the same results in almost all cases. -// More information and rare exception can be found in the -// `NumPy 1.25 release notes `_. -// -// Parameters -// ---------- -// array_types : sequence -// A list of dtypes or dtype convertible objects representing arrays. -// scalar_types : sequence -// A list of dtypes or dtype convertible objects representing scalars. -// -// Returns -// ------- -// datatype : dtype -// The common data type, which is the maximum of `array_types` ignoring -// `scalar_types`, unless the maximum of `scalar_types` is of a -// different kind (`dtype.kind`). If the kind is not understood, then -// None is returned. -// -// See Also -// -------- -// dtype, common_type, can_cast, mintypecode -// -// Examples -// -------- -// >>> np.find_common_type([], [np.int64, np.float32, complex]) -// dtype('complex128') -// >>> np.find_common_type([np.int64, np.float32], []) -// dtype('float64') -// -// The standard casting rules ensure that a scalar cannot up-cast an -// array unless the scalar is of a fundamentally different kind of data -// (i.e. under a different hierarchy in the data type hierarchy) then -// the array: -// -// >>> np.find_common_type([np.float32], [np.int64, np.float64]) -// dtype('float32') -// -// Complex is of a different type, so it up-casts the float in the -// `array_types` argument: -// -// >>> np.find_common_type([np.float32], [complex]) -// dtype('complex128') -// -// Type specifier strings are convertible to dtypes and can therefore -// be used instead of dtypes: -// -// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) -// dtype('complex128') -// -// -// -//go:linkname FindCommonType py.find_common_type -func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object -// -// Returns True if first argument is a typecode lower/equal in type hierarchy. -// -// This is like the builtin :func:`issubclass`, but for `dtype`\ s. -// -// Parameters -// ---------- -// arg1, arg2 : dtype_like -// `dtype` or object coercible to one -// -// Returns -// ------- -// out : bool -// -// See Also -// -------- -// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. -// issubsctype, issubclass_ -// -// Examples -// -------- -// `issubdtype` can be used to check the type of arrays: -// -// >>> ints = np.array([1, 2, 3], dtype=np.int32) -// >>> np.issubdtype(ints.dtype, np.integer) -// True -// >>> np.issubdtype(ints.dtype, np.floating) -// False -// -// >>> floats = np.array([1, 2, 3], dtype=np.float32) -// >>> np.issubdtype(floats.dtype, np.integer) -// False -// >>> np.issubdtype(floats.dtype, np.floating) -// True -// -// Similar types of different sizes are not subdtypes of each other: -// -// >>> np.issubdtype(np.float64, np.float32) -// False -// >>> np.issubdtype(np.float32, np.float64) -// False -// -// but both are subtypes of `floating`: -// -// >>> np.issubdtype(np.float64, np.floating) -// True -// >>> np.issubdtype(np.float32, np.floating) -// True -// -// For convenience, dtype-like objects are allowed too: -// -// >>> np.issubdtype('S1', np.string_) -// True -// >>> np.issubdtype('i4', np.signedinteger) -// True -// -// -// -//go:linkname Issubdtype py.issubdtype -func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Set a Python function to be used when pretty printing arrays. -// -// Parameters -// ---------- -// f : function or None -// Function to be used to pretty print arrays. The function should expect -// a single array argument and return a string of the representation of -// the array. If None, the function is reset to the default NumPy function -// to print arrays. -// repr : bool, optional -// If True (default), the function for pretty printing (``__repr__``) -// is set, if False the function that returns the default string -// representation (``__str__``) is set. -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// Examples -// -------- -// >>> def pprint(arr): -// ... return 'HA! - What are you going to do now?' -// ... -// >>> np.set_string_function(pprint) -// >>> a = np.arange(10) -// >>> a -// HA! - What are you going to do now? -// >>> _ = a -// >>> # [0 1 2 3 4 5 6 7 8 9] -// -// We can reset the function to the default: -// -// >>> np.set_string_function(None) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// -// `repr` affects either pretty printing or normal string representation. -// Note that ``__repr__`` is still affected by setting ``__str__`` -// because the width of each array element in the returned string becomes -// equal to the length of the result of ``__str__()``. -// -// >>> x = np.arange(4) -// >>> np.set_string_function(lambda x:'random', repr=False) -// >>> x.__str__() -// 'random' -// >>> x.__repr__() -// 'array([0, 1, 2, 3])' -// -// -// -//go:linkname SetStringFunction py.set_string_function -func SetStringFunction(f *py.Object, repr *py.Object) *py.Object -// -// Set printing options. -// -// These options determine the way floating point numbers, arrays and -// other NumPy objects are displayed. -// -// Parameters -// ---------- -// precision : int or None, optional -// Number of digits of precision for floating point output (default 8). -// May be None if `floatmode` is not `fixed`, to print as many digits as -// necessary to uniquely specify the value. -// threshold : int, optional -// Total number of array elements which trigger summarization -// rather than full repr (default 1000). -// To always use the full repr without summarization, pass `sys.maxsize`. -// edgeitems : int, optional -// Number of array items in summary at beginning and end of -// each dimension (default 3). -// linewidth : int, optional -// The number of characters per line for the purpose of inserting -// line breaks (default 75). -// suppress : bool, optional -// If True, always print floating point numbers using fixed point -// notation, in which case numbers equal to zero in the current precision -// will print as zero. If False, then scientific notation is used when -// absolute value of the smallest number is < 1e-4 or the ratio of the -// maximum absolute value to the minimum is > 1e3. The default is False. -// nanstr : str, optional -// String representation of floating point not-a-number (default nan). -// infstr : str, optional -// String representation of floating point infinity (default inf). -// sign : string, either '-', '+', or ' ', optional -// Controls printing of the sign of floating-point types. If '+', always -// print the sign of positive values. If ' ', always prints a space -// (whitespace character) in the sign position of positive values. If -// '-', omit the sign character of positive values. (default '-') -// formatter : dict of callables, optional -// If not None, the keys should indicate the type(s) that the respective -// formatting function applies to. Callables should return a string. -// Types that are not specified (by their corresponding keys) are handled -// by the default formatters. Individual types for which a formatter -// can be set are: -// -// - 'bool' -// - 'int' -// - 'timedelta' : a `numpy.timedelta64` -// - 'datetime' : a `numpy.datetime64` -// - 'float' -// - 'longfloat' : 128-bit floats -// - 'complexfloat' -// - 'longcomplexfloat' : composed of two 128-bit floats -// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` -// - 'object' : `np.object_` arrays -// -// Other keys that can be used to set a group of types at once are: -// -// - 'all' : sets all types -// - 'int_kind' : sets 'int' -// - 'float_kind' : sets 'float' and 'longfloat' -// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' -// - 'str_kind' : sets 'numpystr' -// floatmode : str, optional -// Controls the interpretation of the `precision` option for -// floating-point types. Can take the following values -// (default maxprec_equal): -// -// * 'fixed': Always print exactly `precision` fractional digits, -// even if this would print more or fewer digits than -// necessary to specify the value uniquely. -// * 'unique': Print the minimum number of fractional digits necessary -// to represent each value uniquely. Different elements may -// have a different number of digits. The value of the -// `precision` option is ignored. -// * 'maxprec': Print at most `precision` fractional digits, but if -// an element can be uniquely represented with fewer digits -// only print it with that many. -// * 'maxprec_equal': Print at most `precision` fractional digits, -// but if every element in the array can be uniquely -// represented with an equal number of fewer digits, use that -// many digits for all elements. -// legacy : string or `False`, optional -// If set to the string `'1.13'` enables 1.13 legacy printing mode. This -// approximates numpy 1.13 print output by including a space in the sign -// position of floats and different behavior for 0d arrays. This also -// enables 1.21 legacy printing mode (described below). -// -// If set to the string `'1.21'` enables 1.21 legacy printing mode. This -// approximates numpy 1.21 print output of complex structured dtypes -// by not inserting spaces after commas that separate fields and after -// colons. -// -// If set to `False`, disables legacy mode. -// -// Unrecognized strings will be ignored with a warning for forward -// compatibility. -// -// .. versionadded:: 1.14.0 -// .. versionchanged:: 1.22.0 -// -// See Also -// -------- -// get_printoptions, printoptions, set_string_function, array2string -// -// Notes -// ----- -// `formatter` is always reset with a call to `set_printoptions`. -// -// Use `printoptions` as a context manager to set the values temporarily. -// -// Examples -// -------- -// Floating point precision can be set: -// -// >>> np.set_printoptions(precision=4) -// >>> np.array([1.123456789]) -// [1.1235] -// -// Long arrays can be summarised: -// -// >>> np.set_printoptions(threshold=5) -// >>> np.arange(10) -// array([0, 1, 2, ..., 7, 8, 9]) -// -// Small results can be suppressed: -// -// >>> eps = np.finfo(float).eps -// >>> x = np.arange(4.) -// >>> x**2 - (x + eps)**2 -// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) -// >>> np.set_printoptions(suppress=True) -// >>> x**2 - (x + eps)**2 -// array([-0., -0., 0., 0.]) -// -// A custom formatter can be used to display array elements as desired: -// -// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) -// >>> x = np.arange(3) -// >>> x -// array([int: 0, int: -1, int: -2]) -// >>> np.set_printoptions() # formatter gets reset -// >>> x -// array([0, 1, 2]) -// -// To put back the default options, you can use: -// -// >>> np.set_printoptions(edgeitems=3, infstr='inf', -// ... linewidth=75, nanstr='nan', precision=8, -// ... suppress=False, threshold=1000, formatter=None) -// -// Also to temporarily override options, use `printoptions` as a context manager: -// -// >>> with np.printoptions(precision=2, suppress=True, threshold=5): -// ... np.linspace(0, 10, 10) -// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) -// -// -// -//go:linkname SetPrintoptions py.set_printoptions -func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object -// -// Return the current print options. -// -// Returns -// ------- -// print_opts : dict -// Dictionary of current print options with keys -// -// - precision : int -// - threshold : int -// - edgeitems : int -// - linewidth : int -// - suppress : bool -// - nanstr : str -// - infstr : str -// - formatter : dict of callables -// - sign : str -// -// For a full description of these options, see `set_printoptions`. -// -// See Also -// -------- -// set_printoptions, printoptions, set_string_function -// -// -// -//go:linkname GetPrintoptions py.get_printoptions -func GetPrintoptions() *py.Object -// Context manager for setting print options. -// -// Set print options for the scope of the `with` block, and restore the old -// options at the end. See `set_printoptions` for the full description of -// available options. -// -// Examples -// -------- -// -// >>> from numpy.testing import assert_equal -// >>> with np.printoptions(precision=2): -// ... np.array([2.0]) / 3 -// array([0.67]) -// -// The `as`-clause of the `with`-statement gives the current print options: -// -// >>> with np.printoptions(precision=2) as opts: -// ... assert_equal(opts, np.get_printoptions()) -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// -// -//go:linkname Printoptions py.printoptions -func Printoptions(__llgo_va_list ...interface{}) *py.Object -// -// Format a floating-point scalar as a decimal string in positional notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed, or if `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// fractional : boolean, optional -// If `True`, the cutoffs of `precision` and `min_digits` refer to the -// total number of digits after the decimal point, including leading -// zeros. -// If `False`, `precision` and `min_digits` refer to the total number of -// significant digits, before or after the decimal point, ignoring leading -// zeros. -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// pad_right : non-negative integer, optional -// Pad the right side of the string with whitespace until at least that -// many characters are to the right of the decimal point. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. Only has an effect if `unique=True` -// in which case additional digits past those necessary to uniquely -// identify the value may be printed, rounding the last additional digit. -// -// -- versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_scientific -// -// Examples -// -------- -// >>> np.format_float_positional(np.float32(np.pi)) -// '3.1415927' -// >>> np.format_float_positional(np.float16(np.pi)) -// '3.14' -// >>> np.format_float_positional(np.float16(0.3)) -// '0.3' -// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) -// '0.3000488281' -// -// -//go:linkname FormatFloatPositional py.format_float_positional -func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object -// -// Format a floating-point scalar as a decimal string in scientific notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed. If `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// exp_digits : non-negative integer, optional -// Pad the exponent with zeros until it contains at least this many digits. -// If omitted, the exponent will be at least 2 digits. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. This only has an effect for -// `unique=True`. In that case more digits than necessary to uniquely -// identify the value may be printed and rounded unbiased. -// -// -- versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_positional -// -// Examples -// -------- -// >>> np.format_float_scientific(np.float32(np.pi)) -// '3.1415927e+00' -// >>> s = np.float32(1.23e24) -// >>> np.format_float_scientific(s, unique=False, precision=15) -// '1.230000071797338e+24' -// >>> np.format_float_scientific(s, exp_digits=4) -// '1.23e+0024' -// -// -//go:linkname FormatFloatScientific py.format_float_scientific -func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object -// -// Return an ndarray of the provided type that satisfies requirements. -// -// This function is useful to be sure that an array with the correct flags -// is returned for passing to compiled code (perhaps through ctypes). -// -// Parameters -// ---------- -// a : array_like -// The object to be converted to a type-and-requirement-satisfying array. -// dtype : data-type -// The required data-type. If None preserve the current dtype. If your -// application requires the data to be in native byteorder, include -// a byteorder specification as a part of the dtype specification. -// requirements : str or sequence of str -// The requirements list can be any of the following -// -// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array -// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array -// * 'ALIGNED' ('A') - ensure a data-type aligned array -// * 'WRITEABLE' ('W') - ensure a writable array -// * 'OWNDATA' ('O') - ensure an array that owns its own data -// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array with specified requirements and type if given. -// -// See Also -// -------- -// asarray : Convert input to an ndarray. -// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// ndarray.flags : Information about the memory layout of the array. -// -// Notes -// ----- -// The returned array will be guaranteed to have the listed requirements -// by making a copy if needed. -// -// Examples -// -------- -// >>> x = np.arange(6).reshape(2,3) -// >>> x.flags -// C_CONTIGUOUS : True -// F_CONTIGUOUS : False -// OWNDATA : False -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False -// -// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) -// >>> y.flags -// C_CONTIGUOUS : False -// F_CONTIGUOUS : True -// OWNDATA : True -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False -// -// -// -//go:linkname Require py.require -func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object -// -// Set how floating-point errors are handled. -// -// Note that operations on integer scalar types (such as `int16`) are -// handled like floating point, and are affected by these settings. -// -// Parameters -// ---------- -// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Set treatment for all types of floating-point errors at once: -// -// - ignore: Take no action when the exception occurs. -// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). -// - raise: Raise a `FloatingPointError`. -// - call: Call a function specified using the `seterrcall` function. -// - print: Print a warning directly to ``stdout``. -// - log: Record error in a Log object specified by `seterrcall`. -// -// The default is not to change the current behavior. -// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for division by zero. -// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point overflow. -// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point underflow. -// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for invalid floating-point operation. -// -// Returns -// ------- -// old_settings : dict -// Dictionary containing the old settings. -// -// See also -// -------- -// seterrcall : Set a callback function for the 'call' mode. -// geterr, geterrcall, errstate -// -// Notes -// ----- -// The floating-point exceptions are defined in the IEEE 754 standard [1]_: -// -// - Division by zero: infinite result obtained from finite numbers. -// - Overflow: result too large to be expressed. -// - Underflow: result so close to zero that some precision -// was lost. -// - Invalid operation: result is not an expressible number, typically -// indicates that a NaN was produced. -// -// .. [1] https://en.wikipedia.org/wiki/IEEE_754 -// -// Examples -// -------- -// >>> old_settings = np.seterr(all='ignore') #seterr to known value -// >>> np.seterr(over='raise') -// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} -// >>> np.seterr(**old_settings) # reset to default -// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} -// -// >>> np.int16(32000) * np.int16(3) -// 30464 -// >>> old_settings = np.seterr(all='warn', over='raise') -// >>> np.int16(32000) * np.int16(3) -// Traceback (most recent call last): -// File "", line 1, in -// FloatingPointError: overflow encountered in scalar multiply -// -// >>> old_settings = np.seterr(all='print') -// >>> np.geterr() -// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} -// >>> np.int16(32000) * np.int16(3) -// 30464 -// -// -// -//go:linkname Seterr py.seterr -func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object -// -// Get the current way of handling floating-point errors. -// -// Returns -// ------- -// res : dict -// A dictionary with keys "divide", "over", "under", and "invalid", -// whose values are from the strings "ignore", "print", "log", "warn", -// "raise", and "call". The keys represent possible floating-point -// exceptions, and the values define how these exceptions are handled. -// -// See Also -// -------- -// geterrcall, seterr, seterrcall -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterr() -// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) -// array([nan, 1., 1.]) -// -// >>> oldsettings = np.seterr(all='warn', over='raise') -// >>> np.geterr() -// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) -// array([nan, 1., 1.]) -// -// -// -//go:linkname Geterr py.geterr -func Geterr() *py.Object -// -// Set the size of the buffer used in ufuncs. -// -// Parameters -// ---------- -// size : int -// Size of buffer. -// -// -// -//go:linkname Setbufsize py.setbufsize -func Setbufsize(size *py.Object) *py.Object -// -// Return the size of the buffer used in ufuncs. -// -// Returns -// ------- -// getbufsize : int -// Size of ufunc buffer in bytes. -// -// -// -//go:linkname Getbufsize py.getbufsize -func Getbufsize() *py.Object -// -// Set the floating-point error callback function or log object. -// -// There are two ways to capture floating-point error messages. The first -// is to set the error-handler to 'call', using `seterr`. Then, set -// the function to call using this function. -// -// The second is to set the error-handler to 'log', using `seterr`. -// Floating-point errors then trigger a call to the 'write' method of -// the provided object. -// -// Parameters -// ---------- -// func : callable f(err, flag) or object with write method -// Function to call upon floating-point errors ('call'-mode) or -// object whose 'write' method is used to log such message ('log'-mode). -// -// The call function takes two arguments. The first is a string describing -// the type of error (such as "divide by zero", "overflow", "underflow", -// or "invalid value"), and the second is the status flag. The flag is a -// byte, whose four least-significant bits indicate the type of error, one -// of "divide", "over", "under", "invalid":: -// -// [0 0 0 0 divide over under invalid] -// -// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. -// -// If an object is provided, its write method should take one argument, -// a string. -// -// Returns -// ------- -// h : callable, log instance or None -// The old error handler. -// -// See Also -// -------- -// seterr, geterr, geterrcall -// -// Examples -// -------- -// Callback upon error: -// -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// ... -// -// >>> saved_handler = np.seterrcall(err_handler) -// >>> save_err = np.seterr(all='call') -// -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> np.seterrcall(saved_handler) -// -// >>> np.seterr(**save_err) -// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} -// -// Log error message: -// -// >>> class Log: -// ... def write(self, msg): -// ... print("LOG: %s" % msg) -// ... -// -// >>> log = Log() -// >>> saved_handler = np.seterrcall(log) -// >>> save_err = np.seterr(all='log') -// -// >>> np.array([1, 2, 3]) / 0.0 -// LOG: Warning: divide by zero encountered in divide -// array([inf, inf, inf]) -// -// >>> np.seterrcall(saved_handler) -// -// >>> np.seterr(**save_err) -// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} -// -// -// -//go:linkname Seterrcall py.seterrcall -func Seterrcall(func_ *py.Object) *py.Object -// -// Return the current callback function used on floating-point errors. -// -// When the error handling for a floating-point error (one of "divide", -// "over", "under", or "invalid") is set to 'call' or 'log', the function -// that is called or the log instance that is written to is returned by -// `geterrcall`. This function or log instance has been set with -// `seterrcall`. -// -// Returns -// ------- -// errobj : callable, log instance or None -// The current error handler. If no handler was set through `seterrcall`, -// ``None`` is returned. -// -// See Also -// -------- -// seterrcall, seterr, geterr -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterrcall() # we did not yet set a handler, returns None -// -// >>> oldsettings = np.seterr(all='call') -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// >>> oldhandler = np.seterrcall(err_handler) -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> cur_handler = np.geterrcall() -// >>> cur_handler is err_handler -// True -// -// -// -//go:linkname Geterrcall py.geterrcall -func Geterrcall() *py.Object -// -// Return a description for the given data type code. -// -// Parameters -// ---------- -// char : str -// Data type code. -// -// Returns -// ------- -// out : str -// Description of the input data type code. -// -// See Also -// -------- -// dtype, typecodes -// -// Examples -// -------- -// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', -// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] -// >>> for typechar in typechars: -// ... print(typechar, ' : ', np.typename(typechar)) -// ... -// S1 : character -// ? : bool -// B : unsigned char -// D : complex double precision -// G : complex long double precision -// F : complex single precision -// I : unsigned integer -// H : unsigned short -// L : unsigned long integer -// O : object -// Q : unsigned long long integer -// S : string -// U : unicode -// V : void -// b : signed char -// d : double precision -// g : long precision -// f : single precision -// i : integer -// h : short -// l : long integer -// q : long long integer -// -// -// -//go:linkname Typename py.typename -func Typename(char *py.Object) *py.Object -// -// Return the character for the minimum-size type to which given types can -// be safely cast. -// -// The returned type character must represent the smallest size dtype such -// that an array of the returned type can handle the data from an array of -// all types in `typechars` (or if `typechars` is an array, then its -// dtype.char). -// -// Parameters -// ---------- -// typechars : list of str or array_like -// If a list of strings, each string should represent a dtype. -// If array_like, the character representation of the array dtype is used. -// typeset : str or list of str, optional -// The set of characters that the returned character is chosen from. -// The default set is 'GDFgdf'. -// default : str, optional -// The default character, this is returned if none of the characters in -// `typechars` matches a character in `typeset`. -// -// Returns -// ------- -// typechar : str -// The character representing the minimum-size type that was found. -// -// See Also -// -------- -// dtype, sctype2char, maximum_sctype -// -// Examples -// -------- -// >>> np.mintypecode(['d', 'f', 'S']) -// 'd' -// >>> x = np.array([1.1, 2-3.j]) -// >>> np.mintypecode(x) -// 'D' -// -// >>> np.mintypecode('abceh', default='G') -// 'G' -// -// -// -//go:linkname Mintypecode py.mintypecode -func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *py.Object) *py.Object -// -// Return the indices to access the main diagonal of an array. -// -// This returns a tuple of indices that can be used to access the main -// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape -// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for -// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` -// for ``i = [0..n-1]``. -// -// Parameters -// ---------- -// n : int -// The size, along each dimension, of the arrays for which the returned -// indices can be used. -// -// ndim : int, optional -// The number of dimensions. -// -// See Also -// -------- -// diag_indices_from -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Create a set of indices to access the diagonal of a (4, 4) array: -// -// >>> di = np.diag_indices(4) -// >>> di -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// >>> a[di] = 100 -// >>> a -// array([[100, 1, 2, 3], -// [ 4, 100, 6, 7], -// [ 8, 9, 100, 11], -// [ 12, 13, 14, 100]]) -// -// Now, we create indices to manipulate a 3-D array: -// -// >>> d3 = np.diag_indices(2, 3) -// >>> d3 -// (array([0, 1]), array([0, 1]), array([0, 1])) -// -// And use it to set the diagonal of an array of zeros to 1: -// -// >>> a = np.zeros((2, 2, 2), dtype=int) -// >>> a[d3] = 1 -// >>> a -// array([[[1, 0], -// [0, 0]], -// [[0, 0], -// [0, 1]]]) -// -// -// -//go:linkname DiagIndices py.diag_indices -func DiagIndices(n *py.Object, ndim *py.Object) *py.Object -// -// Check whether or not an object can be iterated over. -// -// Parameters -// ---------- -// y : object -// Input object. -// -// Returns -// ------- -// b : bool -// Return ``True`` if the object has an iterator method or is a -// sequence and ``False`` otherwise. -// -// -// Examples -// -------- -// >>> np.iterable([1, 2, 3]) -// True -// >>> np.iterable(2) -// False -// -// Notes -// ----- -// In most cases, the results of ``np.iterable(obj)`` are consistent with -// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is -// the treatment of 0-dimensional arrays:: -// -// >>> from collections.abc import Iterable -// >>> a = np.array(1.0) # 0-dimensional numpy array -// >>> isinstance(a, Iterable) -// True -// >>> np.iterable(a) -// False -// -// -// -//go:linkname Iterable py.iterable -func Iterable(y *py.Object) *py.Object -// -// Display a message on a device. -// -// Parameters -// ---------- -// mesg : str -// Message to display. -// device : object -// Device to write message. If None, defaults to ``sys.stdout`` which is -// very similar to ``print``. `device` needs to have ``write()`` and -// ``flush()`` methods. -// linefeed : bool, optional -// Option whether to print a line feed or not. Defaults to True. -// -// Raises -// ------ -// AttributeError -// If `device` does not have a ``write()`` or ``flush()`` method. -// -// Examples -// -------- -// Besides ``sys.stdout``, a file-like object can also be used as it has -// both required methods: -// -// >>> from io import StringIO -// >>> buf = StringIO() -// >>> np.disp(u'"Display" in a file', device=buf) -// >>> buf.getvalue() -// '"Display" in a file\n' -// -// -// -//go:linkname Disp py.disp -func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object -// Convert the input to an array, checking for NaNs or Infs. -// -// Parameters -// ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes lists, lists of tuples, tuples, tuples of tuples, tuples -// of lists and ndarrays. Success requires no NaNs or Infs. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'C'. -// -// Returns -// ------- -// out : ndarray -// Array interpretation of `a`. No copy is performed if the input -// is already an ndarray. If `a` is a subclass of ndarray, a base -// class ndarray is returned. -// -// Raises -// ------ -// ValueError -// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). -// -// See Also -// -------- -// asarray : Create and array. -// asanyarray : Similar function which passes through subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfarray : Convert input to a floating point ndarray. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. -// -// Examples -// -------- -// Convert a list into an array. If all elements are finite -// ``asarray_chkfinite`` is identical to ``asarray``. -// -// >>> a = [1, 2] -// >>> np.asarray_chkfinite(a, dtype=float) -// array([1., 2.]) -// -// Raises ValueError if array_like contains Nans or Infs. -// -// >>> a = [1, 2, np.inf] -// >>> try: -// ... np.asarray_chkfinite(a) -// ... except ValueError: -// ... print('ValueError') -// ... -// ValueError -// -// -// -//go:linkname AsarrayChkfinite py.asarray_chkfinite -func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Return the Hamming window. -// -// The Hamming window is a taper formed by using a weighted cosine. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, blackman, hanning, kaiser -// -// Notes -// ----- -// The Hamming window is defined as -// -// .. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right) -// \qquad 0 \leq n \leq M-1 -// -// The Hamming was named for R. W. Hamming, an associate of J. W. Tukey -// and is described in Blackman and Tukey. It was recommended for -// smoothing the truncated autocovariance function in the time domain. -// Most references to the Hamming window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 109-110. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> np.hamming(12) -// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary -// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, -// 0.15302337, 0.08 ]) -// -// Plot the window and the frequency response: -// -// >>> import matplotlib.pyplot as plt -// >>> from numpy.fft import fft, fftshift -// >>> window = np.hamming(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Hamming window") -// Text(0.5, 1.0, 'Hamming window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> response = 20 * np.log10(mag) -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Hamming window") -// Text(0.5, 1.0, 'Frequency response of Hamming window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// ... -// >>> plt.show() -// -// -// -//go:linkname Hamming py.hamming -func Hamming(M *py.Object) *py.Object -// -// Return the Hanning window. -// -// The Hanning window is a taper formed by using a weighted cosine. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray, shape(M,) -// The window, with the maximum value normalized to one (the value -// one appears only if `M` is odd). -// -// See Also -// -------- -// bartlett, blackman, hamming, kaiser -// -// Notes -// ----- -// The Hanning window is defined as -// -// .. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right) -// \qquad 0 \leq n \leq M-1 -// -// The Hanning was named for Julius von Hann, an Austrian meteorologist. -// It is also known as the Cosine Bell. Some authors prefer that it be -// called a Hann window, to help avoid confusion with the very similar -// Hamming window. -// -// Most references to the Hanning window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 106-108. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> np.hanning(12) -// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, -// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, -// 0.07937323, 0. ]) -// -// Plot the window and its frequency response: -// -// >>> import matplotlib.pyplot as plt -// >>> from numpy.fft import fft, fftshift -// >>> window = np.hanning(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Hann window") -// Text(0.5, 1.0, 'Hann window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of the Hann window") -// Text(0.5, 1.0, 'Frequency response of the Hann window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// ... -// >>> plt.show() -// -// -// -//go:linkname Hanning py.hanning -func Hanning(M *py.Object) *py.Object -// -// Return the Bartlett window. -// -// The Bartlett window is very similar to a triangular window, except -// that the end points are at zero. It is often used in signal -// processing for tapering a signal, without generating too much -// ripple in the frequency domain. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : array -// The triangular window, with the maximum value normalized to one -// (the value one appears only if the number of samples is odd), with -// the first and last samples equal to zero. -// -// See Also -// -------- -// blackman, hamming, hanning, kaiser -// -// Notes -// ----- -// The Bartlett window is defined as -// -// .. math:: w(n) = \frac{2}{M-1} \left( -// \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| -// \right) -// -// Most references to the Bartlett window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. Note that convolution with this window produces linear -// interpolation. It is also known as an apodization (which means "removing -// the foot", i.e. smoothing discontinuities at the beginning and end of the -// sampled signal) or tapering function. The Fourier transform of the -// Bartlett window is the product of two sinc functions. Note the excellent -// discussion in Kanasewich [2]_. -// -// References -// ---------- -// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", -// Biometrika 37, 1-16, 1950. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 109-110. -// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal -// Processing", Prentice-Hall, 1999, pp. 468-471. -// .. [4] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 429. -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.bartlett(12) -// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary -// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, -// 0.18181818, 0. ]) -// -// Plot the window and its frequency response (requires SciPy and matplotlib): -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.bartlett(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Bartlett window") -// Text(0.5, 1.0, 'Bartlett window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Bartlett window") -// Text(0.5, 1.0, 'Frequency response of Bartlett window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> _ = plt.axis('tight') -// >>> plt.show() -// -// -// -//go:linkname Bartlett py.bartlett -func Bartlett(M *py.Object) *py.Object -// -// Return the Blackman window. -// -// The Blackman window is a taper formed by using the first three -// terms of a summation of cosines. It was designed to have close to the -// minimal leakage possible. It is close to optimal, only slightly worse -// than a Kaiser window. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an empty -// array is returned. -// -// Returns -// ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value one -// appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, hamming, hanning, kaiser -// -// Notes -// ----- -// The Blackman window is defined as -// -// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) -// -// Most references to the Blackman window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. It is known as a -// "near optimal" tapering function, almost as good (by some measures) -// as the kaiser window. -// -// References -// ---------- -// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, -// Dover Publications, New York. -// -// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. -// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.blackman(12) -// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary -// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, -// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, -// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) -// -// Plot the window and the frequency response: -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.blackman(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Blackman window") -// Text(0.5, 1.0, 'Blackman window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Blackman window") -// Text(0.5, 1.0, 'Frequency response of Blackman window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> _ = plt.axis('tight') -// >>> plt.show() -// -// -// -//go:linkname Blackman py.blackman -func Blackman(M *py.Object) *py.Object -// -// Return the Kaiser window. -// -// The Kaiser window is a taper formed by using a Bessel function. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// beta : float -// Shape parameter for window. -// -// Returns -// ------- -// out : array -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, blackman, hamming, hanning -// -// Notes -// ----- -// The Kaiser window is defined as -// -// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} -// \right)/I_0(\beta) -// -// with -// -// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, -// -// where :math:`I_0` is the modified zeroth-order Bessel function. -// -// The Kaiser was named for Jim Kaiser, who discovered a simple -// approximation to the DPSS window based on Bessel functions. The Kaiser -// window is a very good approximation to the Digital Prolate Spheroidal -// Sequence, or Slepian window, which is the transform which maximizes the -// energy in the main lobe of the window relative to total energy. -// -// The Kaiser can approximate many other windows by varying the beta -// parameter. -// -// ==== ======================= -// beta Window shape -// ==== ======================= -// 0 Rectangular -// 5 Similar to a Hamming -// 6 Similar to a Hanning -// 8.6 Similar to a Blackman -// ==== ======================= -// -// A beta value of 14 is probably a good starting point. Note that as beta -// gets large, the window narrows, and so the number of samples needs to be -// large enough to sample the increasingly narrow spike, otherwise NaNs will -// get returned. -// -// Most references to the Kaiser window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by -// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. -// John Wiley and Sons, New York, (1966). -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 177-178. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.kaiser(12, 14) -// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary -// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, -// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, -// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) -// -// -// Plot the window and the frequency response: -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.kaiser(51, 14) -// >>> plt.plot(window) -// [] -// >>> plt.title("Kaiser window") -// Text(0.5, 1.0, 'Kaiser window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> response = 20 * np.log10(mag) -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Kaiser window") -// Text(0.5, 1.0, 'Frequency response of Kaiser window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// (-0.5, 0.5, -100.0, ...) # may vary -// >>> plt.show() -// -// -// -//go:linkname Kaiser py.kaiser -func Kaiser(M *py.Object, beta *py.Object) *py.Object -// -// Add documentation to an existing object, typically one defined in C -// -// The purpose is to allow easier editing of the docstrings without requiring -// a re-compile. This exists primarily for internal use within numpy itself. -// -// Parameters -// ---------- -// place : str -// The absolute name of the module to import from -// obj : str -// The name of the object to add documentation to, typically a class or -// function name -// doc : {str, Tuple[str, str], List[Tuple[str, str]]} -// If a string, the documentation to apply to `obj` -// -// If a tuple, then the first element is interpreted as an attribute of -// `obj` and the second as the docstring to apply - ``(method, docstring)`` -// -// If a list, then each element of the list should be a tuple of length -// two - ``[(method1, docstring1), (method2, docstring2), ...]`` -// warn_on_python : bool -// If True, the default, emit `UserWarning` if this is used to attach -// documentation to a pure-python object. -// -// Notes -// ----- -// This routine never raises an error if the docstring can't be written, but -// will raise an error if the object being documented does not exist. -// -// This routine cannot modify read-only docstrings, as appear -// in new-style classes or built-in functions. Because this -// routine never raises an error the caller must check manually -// that the docstrings were changed. -// -// Since this function grabs the ``char *`` from a c-level str object and puts -// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of -// C-API best-practices, by: -// -// - modifying a `PyTypeObject` after calling `PyType_Ready` -// - calling `Py_INCREF` on the str and losing the reference, so the str -// will never be released -// -// If possible it should be avoided. -// -// -//go:linkname AddNewdoc py.add_newdoc -func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object -// Find the wrapper for the array with the highest priority. -// -// In case of ties, leftmost wins. If no wrapper is found, return None -// -// -//go:linkname GetArrayWrap py.get_array_wrap -func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object -// -// Broadcast the input shapes into a single shape. -// -// :ref:`Learn more about broadcasting here `. -// -// .. versionadded:: 1.20.0 -// -// Parameters -// ---------- -// `*args` : tuples of ints, or ints -// The shapes to be broadcast against each other. -// -// Returns -// ------- -// tuple -// Broadcasted shape. -// -// Raises -// ------ -// ValueError -// If the shapes are not compatible and cannot be broadcast according -// to NumPy's broadcasting rules. -// -// See Also -// -------- -// broadcast -// broadcast_arrays -// broadcast_to -// -// Examples -// -------- -// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) -// (3, 2) -// -// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) -// (5, 6, 7) -// -// -//go:linkname BroadcastShapes py.broadcast_shapes -func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object -// -// Return a 2-D array with ones on the diagonal and zeros elsewhere. -// -// Parameters -// ---------- -// N : int -// Number of rows in the output. -// M : int, optional -// Number of columns in the output. If None, defaults to `N`. -// k : int, optional -// Index of the diagonal: 0 (the default) refers to the main diagonal, -// a positive value refers to an upper diagonal, and a negative value -// to a lower diagonal. -// dtype : data-type, optional -// Data-type of the returned array. -// order : {'C', 'F'}, optional -// Whether the output should be stored in row-major (C-style) or -// column-major (Fortran-style) order in memory. -// -// .. versionadded:: 1.14.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// I : ndarray of shape (N,M) -// An array where all elements are equal to zero, except for the `k`-th -// diagonal, whose values are equal to one. -// -// See Also -// -------- -// identity : (almost) equivalent function -// diag : diagonal 2-D array from a 1-D array specified by the user. -// -// Examples -// -------- -// >>> np.eye(2, dtype=int) -// array([[1, 0], -// [0, 1]]) -// >>> np.eye(3, k=1) -// array([[0., 1., 0.], -// [0., 0., 1.], -// [0., 0., 0.]]) -// -// -// -//go:linkname Eye py.eye -func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// An array with ones at and below the given diagonal and zeros elsewhere. -// -// Parameters -// ---------- -// N : int -// Number of rows in the array. -// M : int, optional -// Number of columns in the array. -// By default, `M` is taken equal to `N`. -// k : int, optional -// The sub-diagonal at and below which the array is filled. -// `k` = 0 is the main diagonal, while `k` < 0 is below it, -// and `k` > 0 is above. The default is 0. -// dtype : dtype, optional -// Data type of the returned array. The default is float. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// tri : ndarray of shape (N, M) -// Array with its lower triangle filled with ones and zero elsewhere; -// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. -// -// Examples -// -------- -// >>> np.tri(3, 5, 2, dtype=int) -// array([[1, 1, 1, 0, 0], -// [1, 1, 1, 1, 0], -// [1, 1, 1, 1, 1]]) -// -// >>> np.tri(3, 5, -1) -// array([[0., 0., 0., 0., 0.], -// [1., 0., 0., 0., 0.], -// [1., 1., 0., 0., 0.]]) -// -// -// -//go:linkname Tri py.tri -func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object -// -// Return the indices to access (n, n) arrays, given a masking function. -// -// Assume `mask_func` is a function that, for a square array a of size -// ``(n, n)`` with a possible offset argument `k`, when called as -// ``mask_func(a, k)`` returns a new array with zeros in certain locations -// (functions like `triu` or `tril` do precisely this). Then this function -// returns the indices where the non-zero values would be located. -// -// Parameters -// ---------- -// n : int -// The returned indices will be valid to access arrays of shape (n, n). -// mask_func : callable -// A function whose call signature is similar to that of `triu`, `tril`. -// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. -// `k` is an optional argument to the function. -// k : scalar -// An optional argument which is passed through to `mask_func`. Functions -// like `triu`, `tril` take a second argument that is interpreted as an -// offset. -// -// Returns -// ------- -// indices : tuple of arrays. -// The `n` arrays of indices corresponding to the locations where -// ``mask_func(np.ones((n, n)), k)`` is True. -// -// See Also -// -------- -// triu, tril, triu_indices, tril_indices -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// These are the indices that would allow you to access the upper triangular -// part of any 3x3 array: -// -// >>> iu = np.mask_indices(3, np.triu) -// -// For example, if `a` is a 3x3 array: -// -// >>> a = np.arange(9).reshape(3, 3) -// >>> a -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) -// >>> a[iu] -// array([0, 1, 2, 4, 5, 8]) -// -// An offset can be passed also to the masking function. This gets us the -// indices starting on the first diagonal right of the main one: -// -// >>> iu1 = np.mask_indices(3, np.triu, 1) -// -// with which we now extract only three elements: -// -// >>> a[iu1] -// array([1, 2, 5]) -// -// -// -//go:linkname MaskIndices py.mask_indices -func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object -// -// Return the indices for the lower-triangle of an (n, m) array. -// -// Parameters -// ---------- -// n : int -// The row dimension of the arrays for which the returned -// indices will be valid. -// k : int, optional -// Diagonal offset (see `tril` for details). -// m : int, optional -// .. versionadded:: 1.9.0 -// -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. -// -// -// Returns -// ------- -// inds : tuple of arrays -// The indices for the triangle. The returned tuple contains two arrays, -// each with the indices along one dimension of the array. -// -// See also -// -------- -// triu_indices : similar function, for upper-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// tril, triu -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Compute two different sets of indices to access 4x4 arrays, one for the -// lower triangular part starting at the main diagonal, and one starting two -// diagonals further right: -// -// >>> il1 = np.tril_indices(4) -// >>> il2 = np.tril_indices(4, 2) -// -// Here is how they can be used with a sample array: -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Both for indexing: -// -// >>> a[il1] -// array([ 0, 4, 5, ..., 13, 14, 15]) -// -// And for assigning values: -// -// >>> a[il1] = -1 -// >>> a -// array([[-1, 1, 2, 3], -// [-1, -1, 6, 7], -// [-1, -1, -1, 11], -// [-1, -1, -1, -1]]) -// -// These cover almost the whole array (two diagonals right of the main one): -// -// >>> a[il2] = -10 -// >>> a -// array([[-10, -10, -10, 3], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10]]) -// -// -// -//go:linkname TrilIndices py.tril_indices -func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object -// -// Return the indices for the upper-triangle of an (n, m) array. -// -// Parameters -// ---------- -// n : int -// The size of the arrays for which the returned indices will -// be valid. -// k : int, optional -// Diagonal offset (see `triu` for details). -// m : int, optional -// .. versionadded:: 1.9.0 -// -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. -// -// -// Returns -// ------- -// inds : tuple, shape(2) of ndarrays, shape(`n`) -// The indices for the triangle. The returned tuple contains two arrays, -// each with the indices along one dimension of the array. Can be used -// to slice a ndarray of shape(`n`, `n`). -// -// See also -// -------- -// tril_indices : similar function, for lower-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// triu, tril -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Compute two different sets of indices to access 4x4 arrays, one for the -// upper triangular part starting at the main diagonal, and one starting two -// diagonals further right: -// -// >>> iu1 = np.triu_indices(4) -// >>> iu2 = np.triu_indices(4, 2) -// -// Here is how they can be used with a sample array: -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Both for indexing: -// -// >>> a[iu1] -// array([ 0, 1, 2, ..., 10, 11, 15]) -// -// And for assigning values: -// -// >>> a[iu1] = -1 -// >>> a -// array([[-1, -1, -1, -1], -// [ 4, -1, -1, -1], -// [ 8, 9, -1, -1], -// [12, 13, 14, -1]]) -// -// These cover only a small part of the whole array (two diagonals right -// of the main one): -// -// >>> a[iu2] = -10 -// >>> a -// array([[ -1, -1, -10, -10], -// [ 4, -1, -1, -10], -// [ 8, 9, -1, -1], -// [ 12, 13, 14, -1]]) -// -// -// -//go:linkname TriuIndices py.triu_indices -func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object -// -// Determine if a class is a subclass of a second class. -// -// `issubclass_` is equivalent to the Python built-in ``issubclass``, -// except that it returns False instead of raising a TypeError if one -// of the arguments is not a class. -// -// Parameters -// ---------- -// arg1 : class -// Input class. True is returned if `arg1` is a subclass of `arg2`. -// arg2 : class or tuple of classes. -// Input class. If a tuple of classes, True is returned if `arg1` is a -// subclass of any of the tuple elements. -// -// Returns -// ------- -// out : bool -// Whether `arg1` is a subclass of `arg2` or not. -// -// See Also -// -------- -// issubsctype, issubdtype, issctype -// -// Examples -// -------- -// >>> np.issubclass_(np.int32, int) -// False -// >>> np.issubclass_(np.int32, float) -// False -// >>> np.issubclass_(np.float64, float) -// True -// -// -// -//go:linkname Issubclass py.issubclass_ -func Issubclass(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Determine if the first argument is a subclass of the second argument. -// -// Parameters -// ---------- -// arg1, arg2 : dtype or dtype specifier -// Data-types. -// -// Returns -// ------- -// out : bool -// The result. -// -// See Also -// -------- -// issctype, issubdtype, obj2sctype -// -// Examples -// -------- -// >>> np.issubsctype('S8', str) -// False -// >>> np.issubsctype(np.array([1]), int) -// True -// >>> np.issubsctype(np.array([1]), float) -// False -// -// -// -//go:linkname Issubsctype py.issubsctype -func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Issues a DeprecationWarning, adds warning to `old_name`'s -// docstring, rebinds ``old_name.__name__`` and returns the new -// function object. -// -// This function may also be used as a decorator. -// -// Parameters -// ---------- -// func : function -// The function to be deprecated. -// old_name : str, optional -// The name of the function to be deprecated. Default is None, in -// which case the name of `func` is used. -// new_name : str, optional -// The new name for the function. Default is None, in which case the -// deprecation message is that `old_name` is deprecated. If given, the -// deprecation message is that `old_name` is deprecated and `new_name` -// should be used instead. -// message : str, optional -// Additional explanation of the deprecation. Displayed in the -// docstring after the warning. -// -// Returns -// ------- -// old_func : function -// The deprecated function. -// -// Examples -// -------- -// Note that ``olduint`` returns a value after printing Deprecation -// Warning: -// -// >>> olduint = np.deprecate(np.uint) -// DeprecationWarning: `uint64` is deprecated! # may vary -// >>> olduint(6) -// 6 -// -// -// -//go:linkname Deprecate py.deprecate -func Deprecate(__llgo_va_list ...interface{}) *py.Object -// -// Deprecates a function and includes the deprecation in its docstring. -// -// This function is used as a decorator. It returns an object that can be -// used to issue a DeprecationWarning, by passing the to-be decorated -// function as argument, this adds warning to the to-be decorated function's -// docstring and returns the new function object. -// -// See Also -// -------- -// deprecate : Decorate a function such that it issues a `DeprecationWarning` -// -// Parameters -// ---------- -// msg : str -// Additional explanation of the deprecation. Displayed in the -// docstring after the warning. -// -// Returns -// ------- -// obj : object -// -// -// -//go:linkname DeprecateWithDoc py.deprecate_with_doc -func DeprecateWithDoc(msg *py.Object) *py.Object -// -// Return the directory that contains the NumPy \*.h header files. -// -// Extension modules that need to compile against NumPy should use this -// function to locate the appropriate include directory. -// -// Notes -// ----- -// When using ``distutils``, for example in ``setup.py``:: -// -// import numpy as np -// ... -// Extension('extension_name', ... -// include_dirs=[np.get_include()]) -// ... -// -// -// -//go:linkname GetInclude py.get_include -func GetInclude() *py.Object -// -// Get help information for an array, function, class, or module. -// -// Parameters -// ---------- -// object : object or str, optional -// Input object or name to get information about. If `object` is -// an `ndarray` instance, information about the array is printed. -// If `object` is a numpy object, its docstring is given. If it is -// a string, available modules are searched for matching objects. -// If None, information about `info` itself is returned. -// maxwidth : int, optional -// Printing width. -// output : file like object, optional -// File like object that the output is written to, default is -// ``None``, in which case ``sys.stdout`` will be used. -// The object has to be opened in 'w' or 'a' mode. -// toplevel : str, optional -// Start search at this level. -// -// See Also -// -------- -// source, lookfor -// -// Notes -// ----- -// When used interactively with an object, ``np.info(obj)`` is equivalent -// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython -// prompt. -// -// Examples -// -------- -// >>> np.info(np.polyval) # doctest: +SKIP -// polyval(p, x) -// Evaluate the polynomial p at x. -// ... -// -// When using a string for `object` it is possible to get multiple results. -// -// >>> np.info('fft') # doctest: +SKIP -// *** Found in numpy *** -// Core FFT routines -// ... -// *** Found in numpy.fft *** -// fft(a, n=None, axis=-1) -// ... -// *** Repeat reference found in numpy.fft.fftpack *** -// *** Total of 3 references found. *** -// -// When the argument is an array, information about the array is printed. -// -// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) -// >>> np.info(a) -// class: ndarray -// shape: (2, 3) -// strides: (24, 8) -// itemsize: 8 -// aligned: True -// contiguous: True -// fortran: False -// data pointer: 0x562b6e0d2860 # may vary -// byteorder: little -// byteswap: False -// type: complex64 -// -// -// -//go:linkname Info py.info -func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object -// -// Print or write to a file the source code for a NumPy object. -// -// The source code is only returned for objects written in Python. Many -// functions and classes are defined in C and will therefore not return -// useful information. -// -// Parameters -// ---------- -// object : numpy object -// Input object. This can be any object (function, class, module, -// ...). -// output : file object, optional -// If `output` not supplied then source code is printed to screen -// (sys.stdout). File object must be created with either write 'w' or -// append 'a' modes. -// -// See Also -// -------- -// lookfor, info -// -// Examples -// -------- -// >>> np.source(np.interp) #doctest: +SKIP -// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py -// def interp(x, xp, fp, left=None, right=None): -// """.... (full docstring printed)""" -// if isinstance(x, (float, int, number)): -// return compiled_interp([x], xp, fp, left, right).item() -// else: -// return compiled_interp(x, xp, fp, left, right) -// -// The source code is only returned for objects written in Python. -// -// >>> np.source(np.array) #doctest: +SKIP -// Not available for this object. -// -// -// -//go:linkname Source py.source -func Source(object *py.Object, output *py.Object) *py.Object -// -// Print the NumPy arrays in the given dictionary. -// -// If there is no dictionary passed in or `vardict` is None then returns -// NumPy arrays in the globals() dictionary (all NumPy arrays in the -// namespace). -// -// Parameters -// ---------- -// vardict : dict, optional -// A dictionary possibly containing ndarrays. Default is globals(). -// -// Returns -// ------- -// out : None -// Returns 'None'. -// -// Notes -// ----- -// Prints out the name, shape, bytes and type of all of the ndarrays -// present in `vardict`. -// -// Examples -// -------- -// >>> a = np.arange(10) -// >>> b = np.ones(20) -// >>> np.who() -// Name Shape Bytes Type -// =========================================================== -// a 10 80 int64 -// b 20 160 float64 -// Upper bound on total bytes = 240 -// -// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', -// ... 'idx':5} -// >>> np.who(d) -// Name Shape Bytes Type -// =========================================================== -// x 2 16 float64 -// y 3 24 float64 -// Upper bound on total bytes = 40 -// -// -// -//go:linkname Who py.who -func Who(vardict *py.Object) *py.Object -// -// Do a keyword search on docstrings. -// -// A list of objects that matched the search is displayed, -// sorted by relevance. All given keywords need to be found in the -// docstring for it to be returned as a result, but the order does -// not matter. -// -// Parameters -// ---------- -// what : str -// String containing words to look for. -// module : str or list, optional -// Name of module(s) whose docstrings to go through. -// import_modules : bool, optional -// Whether to import sub-modules in packages. Default is True. -// regenerate : bool, optional -// Whether to re-generate the docstring cache. Default is False. -// output : file-like, optional -// File-like object to write the output to. If omitted, use a pager. -// -// See Also -// -------- -// source, info -// -// Notes -// ----- -// Relevance is determined only roughly, by checking if the keywords occur -// in the function name, at the start of a docstring, etc. -// -// Examples -// -------- -// >>> np.lookfor('binary representation') # doctest: +SKIP -// Search results for 'binary representation' -// ------------------------------------------ -// numpy.binary_repr -// Return the binary representation of the input number as a string. -// numpy.core.setup_common.long_double_representation -// Given a binary dump as given by GNU od -b, look for long double -// numpy.base_repr -// Return a string representation of a number in the given base system. -// ... -// -// -// -//go:linkname Lookfor py.lookfor -func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object -// -// Returns pointers to the end-points of an array. -// -// Parameters -// ---------- -// a : ndarray -// Input array. It must conform to the Python-side of the array -// interface. -// -// Returns -// ------- -// (low, high) : tuple of 2 integers -// The first integer is the first byte of the array, the second -// integer is just past the last byte of the array. If `a` is not -// contiguous it will not use every byte between the (`low`, `high`) -// values. -// -// Examples -// -------- -// >>> I = np.eye(2, dtype='f'); I.dtype -// dtype('float32') -// >>> low, high = np.byte_bounds(I) -// >>> high - low == I.size*I.itemsize -// True -// >>> I = np.eye(2); I.dtype -// dtype('float64') -// >>> low, high = np.byte_bounds(I) -// >>> high - low == I.size*I.itemsize -// True -// -// -// -//go:linkname ByteBounds py.byte_bounds -func ByteBounds(a *py.Object) *py.Object -// -// Protected string evaluation. -// -// Evaluate a string containing a Python literal expression without -// allowing the execution of arbitrary non-literal code. -// -// .. warning:: -// -// This function is identical to :py:meth:`ast.literal_eval` and -// has the same security implications. It may not always be safe -// to evaluate large input strings. -// -// Parameters -// ---------- -// source : str -// The string to evaluate. -// -// Returns -// ------- -// obj : object -// The result of evaluating `source`. -// -// Raises -// ------ -// SyntaxError -// If the code has invalid Python syntax, or if it contains -// non-literal code. -// -// Examples -// -------- -// >>> np.safe_eval('1') -// 1 -// >>> np.safe_eval('[1, 2, 3]') -// [1, 2, 3] -// >>> np.safe_eval('{"foo": ("bar", 10.0)}') -// {'foo': ('bar', 10.0)} -// -// >>> np.safe_eval('import os') -// Traceback (most recent call last): -// ... -// SyntaxError: invalid syntax -// -// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') -// Traceback (most recent call last): -// ... -// ValueError: malformed node or string: <_ast.Call object at 0x...> -// -// -// -//go:linkname SafeEval py.safe_eval -func SafeEval(source *py.Object) *py.Object -// -// Print information about various resources in the system -// including available intrinsic support and BLAS/LAPACK library -// in use -// -// .. versionadded:: 1.24.0 -// -// See Also -// -------- -// show_config : Show libraries in the system on which NumPy was built. -// -// Notes -// ----- -// 1. Information is derived with the help of `threadpoolctl `_ -// library if available. -// 2. SIMD related information is derived from ``__cpu_features__``, -// ``__cpu_baseline__`` and ``__cpu_dispatch__`` -// -// -// -//go:linkname ShowRuntime py.show_runtime -func ShowRuntime() *py.Object -// -// Load data from a text file. -// -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : data-type, optional -// Data-type of the resulting array; default: float. If this is a -// structured data-type, the resulting array will be 1-dimensional, and -// each row will be interpreted as an element of the array. In this -// case, the number of columns used must match the number of fields in -// the data-type. -// comments : str or sequence of str or None, optional -// The characters or list of characters used to indicate the start of a -// comment. None implies no comments. For backwards compatibility, byte -// strings will be decoded as 'latin1'. The default is '#'. -// delimiter : str, optional -// The character used to separate the values. For backwards compatibility, -// byte strings will be decoded as 'latin1'. The default is whitespace. -// -// .. versionchanged:: 1.23.0 -// Only single character delimiters are supported. Newline characters -// cannot be used as the delimiter. -// -// converters : dict or callable, optional -// Converter functions to customize value parsing. If `converters` is -// callable, the function is applied to all columns, else it must be a -// dict that maps column number to a parser function. -// See examples for further details. -// Default: None. -// -// .. versionchanged:: 1.23.0 -// The ability to pass a single callable to be applied to all columns -// was added. -// -// skiprows : int, optional -// Skip the first `skiprows` lines, including comments; default: 0. -// usecols : int or sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. -// The default, None, results in all columns being read. -// -// .. versionchanged:: 1.11.0 -// When a single column has to be read it is possible to use -// an integer instead of a tuple. E.g ``usecols = 3`` reads the -// fourth column the same way as ``usecols = (3,)`` would. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = loadtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// ndmin : int, optional -// The returned array will have at least `ndmin` dimensions. -// Otherwise mono-dimensional axes will be squeezed. -// Legal values: 0 (default), 1 or 2. -// -// .. versionadded:: 1.6.0 -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply to input streams. -// The special value 'bytes' enables backward compatibility workarounds -// that ensures you receive byte arrays as results if possible and passes -// 'latin1' encoded strings to converters. Override this value to receive -// unicode arrays and pass strings as input to converters. If set to None -// the system default is used. The default value is 'bytes'. -// -// .. versionadded:: 1.14.0 -// max_rows : int, optional -// Read `max_rows` rows of content after `skiprows` lines. The default is -// to read all the rows. Note that empty rows containing no data such as -// empty lines and comment lines are not counted towards `max_rows`, -// while such lines are counted in `skiprows`. -// -// .. versionadded:: 1.16.0 -// -// .. versionchanged:: 1.23.0 -// Lines containing no data, including comment lines (e.g., lines -// starting with '#' or as specified via `comments`) are not counted -// towards `max_rows`. -// quotechar : unicode character or None, optional -// The character used to denote the start and end of a quoted item. -// Occurrences of the delimiter or comment characters are ignored within -// a quoted item. The default value is ``quotechar=None``, which means -// quoting support is disabled. -// -// If two consecutive instances of `quotechar` are found within a quoted -// field, the first is treated as an escape character. See examples. -// -// .. versionadded:: 1.23.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Data read from the text file. -// -// See Also -// -------- -// load, fromstring, fromregex -// genfromtxt : Load data with missing values handled as specified. -// scipy.io.loadmat : reads MATLAB data files -// -// Notes -// ----- -// This function aims to be a fast reader for simply formatted files. The -// `genfromtxt` function provides more sophisticated handling of, e.g., -// lines with missing values. -// -// Each row in the input text file must have the same number of values to be -// able to read all values. If all rows do not have same number of values, a -// subset of up to n columns (where n is the least number of values present -// in all rows) can be read by specifying the columns via `usecols`. -// -// .. versionadded:: 1.10.0 -// -// The strings produced by the Python float.hex method can be used as -// input for floats. -// -// Examples -// -------- -// >>> from io import StringIO # StringIO behaves like a file object -// >>> c = StringIO("0 1\n2 3") -// >>> np.loadtxt(c) -// array([[0., 1.], -// [2., 3.]]) -// -// >>> d = StringIO("M 21 72\nF 35 58") -// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), -// ... 'formats': ('S1', 'i4', 'f4')}) -// array([(b'M', 21, 72.), (b'F', 35, 58.)], -// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") -// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) -// >>> x -// array([1., 3.]) -// >>> y -// array([2., 4.]) -// -// The `converters` argument is used to specify functions to preprocess the -// text prior to parsing. `converters` can be a dictionary that maps -// preprocessing functions to each column: -// -// >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n") -// >>> conv = { -// ... 0: lambda x: np.floor(float(x)), # conversion fn for column 0 -// ... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1 -// ... } -// >>> np.loadtxt(s, delimiter=",", converters=conv) -// array([[1., 3.], -// [3., 5.]]) -// -// `converters` can be a callable instead of a dictionary, in which case it -// is applied to all columns: -// -// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") -// >>> import functools -// >>> conv = functools.partial(int, base=16) -// >>> np.loadtxt(s, converters=conv) -// array([[222., 173.], -// [192., 222.]]) -// -// This example shows how `converters` can be used to convert a field -// with a trailing minus sign into a negative number. -// -// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') -// >>> def conv(fld): -// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) -// ... -// >>> np.loadtxt(s, converters=conv) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) -// -// Using a callable as the converter can be particularly useful for handling -// values with different formatting, e.g. floats with underscores: -// -// >>> s = StringIO("1 2.7 100_000") -// >>> np.loadtxt(s, converters=float) -// array([1.e+00, 2.7e+00, 1.e+05]) -// -// This idea can be extended to automatically handle values specified in -// many different formats: -// -// >>> def conv(val): -// ... try: -// ... return float(val) -// ... except ValueError: -// ... return float.fromhex(val) -// >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2") -// >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None) -// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) -// -// Note that with the default ``encoding="bytes"``, the inputs to the -// converter function are latin-1 encoded byte strings. To deactivate the -// implicit encoding prior to conversion, use ``encoding=None`` -// -// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') -// >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x) -// >>> np.loadtxt(s, converters=conv, encoding=None) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) -// -// Support for quoted fields is enabled with the `quotechar` parameter. -// Comment and delimiter characters are ignored when they appear within a -// quoted item delineated by `quotechar`: -// -// >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n') -// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) -// >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"') -// array([('alpha, #42', 10.), ('beta, #64', 2.)], -// dtype=[('label', '>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n') -// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) -// >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"') -// array([('alpha, #42', 10.), ('beta, #64', 2.)], -// dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"') -// >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"') -// array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20") -// >>> np.loadtxt(d, usecols=(0, 1)) -// array([[ 1., 2.], -// [ 2., 4.], -// [ 3., 9.], -// [ 4., 16.]]) -// -// -// -//go:linkname Loadtxt py.loadtxt -func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object -// -// Load data from a text file, with missing values handled as specified. -// -// Each line past the first `skip_header` lines is split at the `delimiter` -// character, and characters following the `comments` character are discarded. -// -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : dtype, optional -// Data type of the resulting array. -// If None, the dtypes will be determined by the contents of each -// column, individually. -// comments : str, optional -// The character used to indicate the start of a comment. -// All the characters occurring on a line after a comment are discarded. -// delimiter : str, int, or sequence, optional -// The string used to separate values. By default, any consecutive -// whitespaces act as delimiter. An integer or sequence of integers -// can also be provided as width(s) of each field. -// skiprows : int, optional -// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. -// skip_header : int, optional -// The number of lines to skip at the beginning of the file. -// skip_footer : int, optional -// The number of lines to skip at the end of the file. -// converters : variable, optional -// The set of functions that convert the data of a column to a value. -// The converters can also be used to provide a default value -// for missing data: ``converters = {3: lambda s: float(s or 0)}``. -// missing : variable, optional -// `missing` was removed in numpy 1.10. Please use `missing_values` -// instead. -// missing_values : variable, optional -// The set of strings corresponding to missing data. -// filling_values : variable, optional -// The set of values to be used as default when the data are missing. -// usecols : sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. -// names : {None, True, str, sequence}, optional -// If `names` is True, the field names are read from the first line after -// the first `skip_header` lines. This line can optionally be preceded -// by a comment delimiter. If `names` is a sequence or a single-string of -// comma-separated names, the names will be used to define the field names -// in a structured dtype. If `names` is None, the names of the dtype -// fields will be used, if any. -// excludelist : sequence, optional -// A list of names to exclude. This list is appended to the default list -// ['return','file','print']. Excluded names are appended with an -// underscore: for example, `file` would become `file_`. -// deletechars : str, optional -// A string combining invalid characters that must be deleted from the -// names. -// defaultfmt : str, optional -// A format used to define default field names, such as "f%i" or "f_%02i". -// autostrip : bool, optional -// Whether to automatically strip white spaces from the variables. -// replace_space : char, optional -// Character(s) used in replacement of white spaces in the variable -// names. By default, use a '_'. -// case_sensitive : {True, False, 'upper', 'lower'}, optional -// If True, field names are case sensitive. -// If False or 'upper', field names are converted to upper case. -// If 'lower', field names are converted to lower case. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = genfromtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// usemask : bool, optional -// If True, return a masked array. -// If False, return a regular array. -// loose : bool, optional -// If True, do not raise errors for invalid values. -// invalid_raise : bool, optional -// If True, an exception is raised if an inconsistency is detected in the -// number of columns. -// If False, a warning is emitted and the offending lines are skipped. -// max_rows : int, optional -// The maximum number of rows to read. Must not be used with skip_footer -// at the same time. If given, the value must be at least 1. Default is -// to read the entire file. -// -// .. versionadded:: 1.10.0 -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply when `fname` is -// a file object. The special value 'bytes' enables backward compatibility -// workarounds that ensure that you receive byte arrays when possible -// and passes latin1 encoded strings to converters. Override this value to -// receive unicode arrays and pass strings as input to converters. If set -// to None the system default is used. The default value is 'bytes'. -// -// .. versionadded:: 1.14.0 -// ndmin : int, optional -// Same parameter as `loadtxt` -// -// .. versionadded:: 1.23.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Data read from the text file. If `usemask` is True, this is a -// masked array. -// -// See Also -// -------- -// numpy.loadtxt : equivalent function when no data is missing. -// -// Notes -// ----- -// * When spaces are used as delimiters, or when no delimiter has been given -// as input, there should not be any missing data between two fields. -// * When the variables are named (either by a flexible dtype or with `names`), -// there must not be any header in the file (else a ValueError -// exception is raised). -// * Individual values are not stripped of spaces by default. -// When using a custom converter, make sure the function does remove spaces. -// -// References -// ---------- -// .. [1] NumPy User Guide, section `I/O with NumPy -// `_. -// -// Examples -// -------- -// >>> from io import StringIO -// >>> import numpy as np -// -// Comma delimited file with mixed dtype -// -// >>> s = StringIO(u"1,1.3,abcde") -// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), -// ... ('mystring','S5')], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only -// >>> data = np.genfromtxt(s, dtype=None, -// ... names = ['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) -// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", -// ... names=['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> s = StringIO(u"11.3abcde") -// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], -// ... delimiter=[1,3,5]) -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('intvar', '>> f = StringIO(''' -// ... text,# of chars -// ... hello world,11 -// ... numpy,5''') -// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') -// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], -// dtype=[('f0', 'S12'), ('f1', 'S12')]) -// -// -// -//go:linkname Genfromtxt py.genfromtxt -func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object -// -// Load ASCII data from a file and return it in a record array. -// -// If ``usemask=False`` a standard `recarray` is returned, -// if ``usemask=True`` a MaskedRecords array is returned. -// -// Parameters -// ---------- -// fname, kwargs : For a description of input parameters, see `genfromtxt`. -// -// See Also -// -------- -// numpy.genfromtxt : generic function -// -// Notes -// ----- -// By default, `dtype` is None, which means that the data-type of the output -// array will be determined from the data. -// -// -// -//go:linkname Recfromtxt py.recfromtxt -func Recfromtxt(fname *py.Object) *py.Object -// -// Load ASCII data stored in a comma-separated file. -// -// The returned array is a record array (if ``usemask=False``, see -// `recarray`) or a masked record array (if ``usemask=True``, -// see `ma.mrecords.MaskedRecords`). -// -// Parameters -// ---------- -// fname, kwargs : For a description of input parameters, see `genfromtxt`. -// -// See Also -// -------- -// numpy.genfromtxt : generic function to load ASCII data. -// -// Notes -// ----- -// By default, `dtype` is None, which means that the data-type of the output -// array will be determined from the data. -// -// -// -//go:linkname Recfromcsv py.recfromcsv -func Recfromcsv(fname *py.Object) *py.Object -// -// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. -// -// .. warning:: Loading files that contain object arrays uses the ``pickle`` -// module, which is not secure against erroneous or maliciously -// constructed data. Consider passing ``allow_pickle=False`` to -// load data that is known not to contain object arrays for the -// safer handling of untrusted sources. -// -// Parameters -// ---------- -// file : file-like object, string, or pathlib.Path -// The file to read. File-like objects must support the -// ``seek()`` and ``read()`` methods and must always -// be opened in binary mode. Pickled files require that the -// file-like object support the ``readline()`` method as well. -// mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional -// If not None, then memory-map the file, using the given mode (see -// `numpy.memmap` for a detailed description of the modes). A -// memory-mapped array is kept on disk. However, it can be accessed -// and sliced like any ndarray. Memory mapping is especially useful -// for accessing small fragments of large files without reading the -// entire file into memory. -// allow_pickle : bool, optional -// Allow loading pickled object arrays stored in npy files. Reasons for -// disallowing pickles include security, as loading pickled data can -// execute arbitrary code. If pickles are disallowed, loading object -// arrays will fail. Default: False -// -// .. versionchanged:: 1.16.3 -// Made default False in response to CVE-2019-6446. -// -// fix_imports : bool, optional -// Only useful when loading Python 2 generated pickled files on Python 3, -// which includes npy/npz files containing object arrays. If `fix_imports` -// is True, pickle will try to map the old Python 2 names to the new names -// used in Python 3. -// encoding : str, optional -// What encoding to use when reading Python 2 strings. Only useful when -// loading Python 2 generated pickled files in Python 3, which includes -// npy/npz files containing object arrays. Values other than 'latin1', -// 'ASCII', and 'bytes' are not allowed, as they can corrupt numerical -// data. Default: 'ASCII' -// max_header_size : int, optional -// Maximum allowed size of the header. Large headers may not be safe -// to load securely and thus require explicitly passing a larger value. -// See :py:func:`ast.literal_eval()` for details. -// This option is ignored when `allow_pickle` is passed. In that case -// the file is by definition trusted and the limit is unnecessary. -// -// Returns -// ------- -// result : array, tuple, dict, etc. -// Data stored in the file. For ``.npz`` files, the returned instance -// of NpzFile class must be closed to avoid leaking file descriptors. -// -// Raises -// ------ -// OSError -// If the input file does not exist or cannot be read. -// UnpicklingError -// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. -// ValueError -// The file contains an object array, but ``allow_pickle=False`` given. -// EOFError -// When calling ``np.load`` multiple times on the same file handle, -// if all data has already been read -// -// See Also -// -------- -// save, savez, savez_compressed, loadtxt -// memmap : Create a memory-map to an array stored in a file on disk. -// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. -// -// Notes -// ----- -// - If the file contains pickle data, then whatever object is stored -// in the pickle is returned. -// - If the file is a ``.npy`` file, then a single array is returned. -// - If the file is a ``.npz`` file, then a dictionary-like object is -// returned, containing ``{filename: array}`` key-value pairs, one for -// each file in the archive. -// - If the file is a ``.npz`` file, the returned value supports the -// context manager protocol in a similar fashion to the open function:: -// -// with load('foo.npz') as data: -// a = data['a'] -// -// The underlying file descriptor is closed when exiting the 'with' -// block. -// -// Examples -// -------- -// Store data to disk, and load it again: -// -// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) -// >>> np.load('/tmp/123.npy') -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// Store compressed data to disk, and load it again: -// -// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) -// >>> b=np.array([1, 2]) -// >>> np.savez('/tmp/123.npz', a=a, b=b) -// >>> data = np.load('/tmp/123.npz') -// >>> data['a'] -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> data['b'] -// array([1, 2]) -// >>> data.close() -// -// Mem-map the stored array, and then access the second row -// directly from disk: -// -// >>> X = np.load('/tmp/123.npy', mmap_mode='r') -// >>> X[1, :] -// memmap([4, 5, 6]) -// -// -// -//go:linkname Load py.load -func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object -// -// Build a matrix object from a string, nested sequence, or array. -// -// Parameters -// ---------- -// obj : str or array_like -// Input data. If a string, variables in the current scope may be -// referenced by name. -// ldict : dict, optional -// A dictionary that replaces local operands in current frame. -// Ignored if `obj` is not a string or `gdict` is None. -// gdict : dict, optional -// A dictionary that replaces global operands in current frame. -// Ignored if `obj` is not a string. -// -// Returns -// ------- -// out : matrix -// Returns a matrix object, which is a specialized 2-D array. -// -// See Also -// -------- -// block : -// A generalization of this function for N-d arrays, that returns normal -// ndarrays. -// -// Examples -// -------- -// >>> A = np.mat('1 1; 1 1') -// >>> B = np.mat('2 2; 2 2') -// >>> C = np.mat('3 4; 5 6') -// >>> D = np.mat('7 8; 9 0') -// -// All the following expressions construct the same block matrix: -// -// >>> np.bmat([[A, B], [C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat('A,B; C,D') -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// -// -// -//go:linkname Bmat py.bmat -func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object -// -// Interpret the input as a matrix. -// -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. -// -// Parameters -// ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. -// -// Returns -// ------- -// mat : matrix -// `data` interpreted as a matrix. -// -// Examples -// -------- -// >>> x = np.array([[1, 2], [3, 4]]) -// -// >>> m = np.asmatrix(x) -// -// >>> x[0,0] = 5 -// -// >>> m -// matrix([[5, 2], -// [3, 4]]) -// -// -// -//go:linkname Mat py.mat -func Mat(data *py.Object, dtype *py.Object) *py.Object -// -// Interpret the input as a matrix. -// -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. -// -// Parameters -// ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. -// -// Returns -// ------- -// mat : matrix -// `data` interpreted as a matrix. -// -// Examples -// -------- -// >>> x = np.array([[1, 2], [3, 4]]) -// -// >>> m = np.asmatrix(x) -// -// >>> x[0,0] = 5 -// -// >>> m -// matrix([[5, 2], -// [3, 4]]) -// -// -// -//go:linkname Asmatrix py.asmatrix -func Asmatrix(data *py.Object, dtype *py.Object) *py.Object -// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the absolute value element-wise. -// -// ``np.abs`` is a shorthand for this function. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// absolute : ndarray -// An ndarray containing the absolute value of -// each element in `x`. For complex input, ``a + ib``, the -// absolute value is :math:`\sqrt{ a^2 + b^2 }`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> x = np.array([-1.2, 1.2]) -// >>> np.absolute(x) -// array([ 1.2, 1.2]) -// >>> np.absolute(1.2 + 1j) -// 1.5620499351813308 -// -// Plot the function over ``[-10, 10]``: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(start=-10, stop=10, num=101) -// >>> plt.plot(x, np.absolute(x)) -// >>> plt.show() -// -// Plot the function over the complex plane: -// -// >>> xx = x + 1j * x[:, np.newaxis] -// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') -// >>> plt.show() -// -// The `abs` function can be used as a shorthand for ``np.absolute`` on -// ndarrays. -// -// >>> x = np.array([-1.2, 1.2]) -// >>> abs(x) -// array([1.2, 1.2]) -// -//go:linkname Abs py.abs -func Abs(__llgo_va_list ...interface{}) *py.Object diff --git a/numpy_1/numpy_autogen_link.go b/numpy_1/numpy_autogen_link.go deleted file mode 100644 index bb5882ce..00000000 --- a/numpy_1/numpy_autogen_link.go +++ /dev/null @@ -1,5 +0,0 @@ -package numpy - -import _ "github.com/goplus/lib/py" - -// LLGoPackage is defined in the main binding file From d0cdbb45b8fe98e7bf2f74071cb731862e752420 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Fri, 15 Aug 2025 10:08:34 +0800 Subject: [PATCH 11/13] Release-as: numpy/v1.26.4 --- .DS_Store | Bin 6148 -> 8196 bytes numpy/_demo/main.go | 9 + numpy/go.mod | 5 + numpy/go.sum | 2 + numpy/llpkg.cfg | 16 + numpy/llpyg.cfg | 155 + numpy/numpy.go | 9572 +++++++++++++++++++++++++++++++++++ numpy/numpy_autogen_link.go | 5 + 8 files changed, 9764 insertions(+) create mode 100644 numpy/_demo/main.go create mode 100644 numpy/go.mod create mode 100644 numpy/go.sum create mode 100644 numpy/llpkg.cfg create mode 100644 numpy/llpyg.cfg create mode 100644 numpy/numpy.go create mode 100644 numpy/numpy_autogen_link.go diff --git a/.DS_Store b/.DS_Store index 59f99ee8aa6f5f1d7326b2a03473eb0fbe623fa7..6e2fecf8339e131c3e3283fa10bc1f2ce5f561b0 100644 GIT binary patch literal 8196 zcmeI1%Wl&^6o${F32{_Wx+thDkSwvSN}7}aViVG2Q3+Ty2o``s+(fOZYlk=?KoluU zF7LoAutPiv@4~A5XU0uEPR+7G>WnmV9M6Ad#@}4r;}Vgm4Le&z>qKNBvt3ETRZS$ll>+OF4q=5W{@>@cgCl8}^XaH?MUPApRMg4(};TQihf$?Sz zQq>{U1HEm@;d_ijo*vUK?NEcBQj;19HM5ATuc1W`bdQ*Z9DSdt=G-NVALG62g9(|?!V+;&w{{nPOsa}bGJKct*-3^{-Evp-M(~i zJ6%X#y>R_bFscPZzY|K|rmC zxYs)Jj{V>(o()MvFAut^e$Pr?X|ZQdrE*uNBH))orIJu$btaTP4KZUq`lu^u56U$) zuO}yRTr*{i^v???ePcXk&RgYwaQ>`_rgHwGKTm>lo@P%hrf z`HYIUs&JXo5Lg6(CDrNrGHfIL`~M<_X8JS)41o(GAhPvly@t+C|2#_e%dxhN{05m5 s>!!*|7Zfrahn3+t?Cc+gxV9l>pK4^M%Hj^vLOukT_rGLsipxvjFIfAp)Bpeg delta 113 zcmZp1XfcprU|?W$DortDU=RQ@Ie-{Mvv5r;6q~50$jG}fU^g=(?`9r>WX8$=1-U0b z5VYLPC>p}Fn4N<|kQt~H2n4u+geyqb#=`H+llf&lL1r*8LCgbL!LT`=XAUy}a(fc; diff --git a/numpy/_demo/main.go b/numpy/_demo/main.go new file mode 100644 index 00000000..15eded01 --- /dev/null +++ b/numpy/_demo/main.go @@ -0,0 +1,9 @@ +package main + +import ( + "fmt" +) + +func main() { + fmt.Println("Hello, World!") +} \ No newline at end of file diff --git a/numpy/go.mod b/numpy/go.mod new file mode 100644 index 00000000..82bc5445 --- /dev/null +++ b/numpy/go.mod @@ -0,0 +1,5 @@ +module github.com/goplus/llpkg/numpy + +go 1.23 + +require github.com/goplus/lib v0.2.0 diff --git a/numpy/go.sum b/numpy/go.sum new file mode 100644 index 00000000..512980a5 --- /dev/null +++ b/numpy/go.sum @@ -0,0 +1,2 @@ +github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= +github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy/llpkg.cfg b/numpy/llpkg.cfg new file mode 100644 index 00000000..44e6cd3e --- /dev/null +++ b/numpy/llpkg.cfg @@ -0,0 +1,16 @@ +{ + "type": "python", + "upstream": { + "installer": { + "name": "pip", + "config": { + "python_version": "3.12", + "index_url": "https://pypi.org/simple/" + } + }, + "package": { + "name": "numpy", + "version": "1.26.4" + } + } +} \ No newline at end of file diff --git a/numpy/llpyg.cfg b/numpy/llpyg.cfg new file mode 100644 index 00000000..b8888a8d --- /dev/null +++ b/numpy/llpyg.cfg @@ -0,0 +1,155 @@ +{ + "name": "numpy", + "module": "numpy", + "python": true, + "symMap": { + "abs": "Abs", + "absolute": "Absolute", + "add": "Add", + "all": "All", + "any": "Any", + "arange": "Arange", + "arccos": "Arccos", + "arccosh": "Arccosh", + "arcsin": "Arcsin", + "arcsinh": "Arcsinh", + "arctan": "Arctan", + "arctanh": "Arctanh", + "array": "Array", + "average": "Average", + "bin": "Bin", + "bool": "Bool", + "c_": "C", + "ceil": "Ceil", + "chr": "Chr", + "corrcoef": "Corrcoef", + "cos": "Cos", + "cosh": "Cosh", + "cov": "Cov", + "cross": "Cross", + "diag": "Diag", + "dict": "Dict", + "dir": "Dir", + "divide": "Divide", + "dot": "Dot", + "einsum": "Einsum", + "empty": "Empty", + "enumerate": "Enumerate", + "exp": "Exp", + "eye": "Eye", + "fabs": "Fabs", + "fft": "Fft", + "filter": "Filter", + "float": "Float", + "floor": "Floor", + "format": "Format", + "frozenset": "FrozenSet", + "getattr": "GetAttr", + "hasattr": "HasAttr", + "hash": "Hash", + "help": "Help", + "hex": "Hex", + "id": "ID", + "identity": "Identity", + "inner": "Inner", + "input": "Input", + "int": "Int", + "isinstance": "IsInstance", + "issubclass": "IsSubclass", + "iter": "Iter", + "len": "Len", + "linalg": "Linalg", + "linspace": "Linspace", + "list": "List", + "locals": "Locals", + "log": "Log", + "log10": "Log10", + "log2": "Log2", + "logspace": "Logspace", + "map": "Map", + "matmul": "Matmul", + "max": "Max", + "mean": "Mean", + "median": "Median", + "meshgrid": "Meshgrid", + "mgrid": "Mgrid", + "min": "Min", + "mod": "Mod", + "multiply": "Multiply", + "next": "Next", + "oct": "Oct", + "ogrid": "Ogrid", + "ones": "Ones", + "open": "Open", + "ord": "Ord", + "outer": "Outer", + "percentile": "Percentile", + "pow": "Pow", + "power": "Power", + "print": "Print", + "prod": "Prod", + "ptp": "Ptp", + "quantile": "Quantile", + "r_": "R", + "random": "Random", + "range": "Range", + "remainder": "Remainder", + "repr": "Repr", + "reversed": "Reversed", + "rint": "Rint", + "round": "Round", + "set": "Set", + "setattr": "SetAttr", + "sign": "Sign", + "sin": "Sin", + "sinh": "Sinh", + "sorted": "Sorted", + "sqrt": "Sqrt", + "std": "Std", + "str": "Str", + "subtract": "Subtract", + "sum": "Sum", + "tan": "Tan", + "tanh": "Tanh", + "tensordot": "Tensordot", + "tri": "Tri", + "tril": "Tril", + "triu": "Triu", + "trunc": "Trunc", + "tuple": "Tuple", + "type": "Type", + "vander": "Vander", + "var": "Var", + "vars": "Vars", + "zeros": "Zeros", + "zip": "Zip" + }, + "deps": [ + "py" + ], + "include": [ + "numpy" + ], + "exclude": [ + "__builtins__", + "__cached__", + "__doc__", + "__file__", + "__loader__", + "__name__", + "__package__", + "__spec__" + ], + "constants": { + "bool_": "Bool", + "e": "E", + "float32": "Float32", + "float64": "Float64", + "inf": "Inf", + "int32": "Int32", + "int64": "Int64", + "nan": "NaN", + "pi": "Pi", + "uint8": "Uint8" + } +} \ No newline at end of file diff --git a/numpy/numpy.go b/numpy/numpy.go new file mode 100644 index 00000000..7cfce191 --- /dev/null +++ b/numpy/numpy.go @@ -0,0 +1,9572 @@ +package numpy + +import ( + "github.com/goplus/lib/py" + _ "unsafe" +) + +const LLGoPackage = "py.numpy" +// +// Show libraries and system information on which NumPy was built +// and is being used +// +// Parameters +// ---------- +// mode : {`'stdout'`, `'dicts'`}, optional. +// Indicates how to display the config information. +// `'stdout'` prints to console, `'dicts'` returns a dictionary +// of the configuration. +// +// Returns +// ------- +// out : {`dict`, `None`} +// If mode is `'dicts'`, a dict is returned, else None +// +// See Also +// -------- +// get_include : Returns the directory containing NumPy C +// header files. +// +// Notes +// ----- +// 1. The `'stdout'` mode will give more readable +// output if ``pyyaml`` is installed +// +// +// +//go:linkname ShowConfig py.show_config +func ShowConfig(mode *py.Object) *py.Object +// +// Return an array representing the indices of a grid. +// +// Compute an array where the subarrays contain index values 0, 1, ... +// varying only along the corresponding axis. +// +// Parameters +// ---------- +// dimensions : sequence of ints +// The shape of the grid. +// dtype : dtype, optional +// Data type of the result. +// sparse : boolean, optional +// Return a sparse representation of the grid instead of a dense +// representation. Default is False. +// +// .. versionadded:: 1.17 +// +// Returns +// ------- +// grid : one ndarray or tuple of ndarrays +// If sparse is False: +// Returns one array of grid indices, +// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. +// If sparse is True: +// Returns a tuple of arrays, with +// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with +// dimensions[i] in the ith place +// +// See Also +// -------- +// mgrid, ogrid, meshgrid +// +// Notes +// ----- +// The output shape in the dense case is obtained by prepending the number +// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` +// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is +// ``(N, r0, ..., rN-1)``. +// +// The subarrays ``grid[k]`` contains the N-D array of indices along the +// ``k-th`` axis. Explicitly:: +// +// grid[k, i0, i1, ..., iN-1] = ik +// +// Examples +// -------- +// >>> grid = np.indices((2, 3)) +// >>> grid.shape +// (2, 2, 3) +// >>> grid[0] # row indices +// array([[0, 0, 0], +// [1, 1, 1]]) +// >>> grid[1] # column indices +// array([[0, 1, 2], +// [0, 1, 2]]) +// +// The indices can be used as an index into an array. +// +// >>> x = np.arange(20).reshape(5, 4) +// >>> row, col = np.indices((2, 3)) +// >>> x[row, col] +// array([[0, 1, 2], +// [4, 5, 6]]) +// +// Note that it would be more straightforward in the above example to +// extract the required elements directly with ``x[:2, :3]``. +// +// If sparse is set to true, the grid will be returned in a sparse +// representation. +// +// >>> i, j = np.indices((2, 3), sparse=True) +// >>> i.shape +// (2, 1) +// >>> j.shape +// (1, 3) +// >>> i # row indices +// array([[0], +// [1]]) +// >>> j # column indices +// array([[0, 1, 2]]) +// +// +// +//go:linkname Indices py.indices +func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object +// +// Construct an array by executing a function over each coordinate. +// +// The resulting array therefore has a value ``fn(x, y, z)`` at +// coordinate ``(x, y, z)``. +// +// Parameters +// ---------- +// function : callable +// The function is called with N parameters, where N is the rank of +// `shape`. Each parameter represents the coordinates of the array +// varying along a specific axis. For example, if `shape` +// were ``(2, 2)``, then the parameters would be +// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` +// shape : (N,) tuple of ints +// Shape of the output array, which also determines the shape of +// the coordinate arrays passed to `function`. +// dtype : data-type, optional +// Data-type of the coordinate arrays passed to `function`. +// By default, `dtype` is float. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// fromfunction : any +// The result of the call to `function` is passed back directly. +// Therefore the shape of `fromfunction` is completely determined by +// `function`. If `function` returns a scalar value, the shape of +// `fromfunction` would not match the `shape` parameter. +// +// See Also +// -------- +// indices, meshgrid +// +// Notes +// ----- +// Keywords other than `dtype` and `like` are passed to `function`. +// +// Examples +// -------- +// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) +// array([[0., 0.], +// [1., 1.]]) +// +// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) +// array([[0., 1.], +// [0., 1.]]) +// +// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) +// array([[ True, False, False], +// [False, True, False], +// [False, False, True]]) +// +// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) +// array([[0, 1, 2], +// [1, 2, 3], +// [2, 3, 4]]) +// +// +// +//go:linkname Fromfunction py.fromfunction +func Fromfunction(function *py.Object, shape *py.Object) *py.Object +// +// Returns True if the type of `element` is a scalar type. +// +// Parameters +// ---------- +// element : any +// Input argument, can be of any type and shape. +// +// Returns +// ------- +// val : bool +// True if `element` is a scalar type, False if it is not. +// +// See Also +// -------- +// ndim : Get the number of dimensions of an array +// +// Notes +// ----- +// If you need a stricter way to identify a *numerical* scalar, use +// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most +// non-numerical elements such as strings. +// +// In most 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: +// +// +--------------------------------------+---------------+-------------------+ +// | x |``isscalar(x)``|``np.ndim(x) == 0``| +// +======================================+===============+===================+ +// | PEP 3141 numeric objects (including | ``True`` | ``True`` | +// | builtins) | | | +// +--------------------------------------+---------------+-------------------+ +// | builtin string and buffer objects | ``True`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other builtin objects, like | ``False`` | ``True`` | +// | `pathlib.Path`, `Exception`, | | | +// | the result of `re.compile` | | | +// +--------------------------------------+---------------+-------------------+ +// | third-party objects like | ``False`` | ``True`` | +// | `matplotlib.figure.Figure` | | | +// +--------------------------------------+---------------+-------------------+ +// | zero-dimensional numpy arrays | ``False`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other numpy arrays | ``False`` | ``False`` | +// +--------------------------------------+---------------+-------------------+ +// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | +// | objects | | | +// +--------------------------------------+---------------+-------------------+ +// +// Examples +// -------- +// >>> np.isscalar(3.1) +// True +// >>> np.isscalar(np.array(3.1)) +// False +// >>> np.isscalar([3.1]) +// False +// >>> np.isscalar(False) +// True +// >>> np.isscalar('numpy') +// True +// +// NumPy supports PEP 3141 numbers: +// +// >>> from fractions import Fraction +// >>> np.isscalar(Fraction(5, 17)) +// True +// >>> from numbers import Number +// >>> np.isscalar(Number()) +// True +// +// +// +//go:linkname Isscalar py.isscalar +func Isscalar(element *py.Object) *py.Object +// +// Return the binary representation of the input number as a string. +// +// For negative numbers, if width is not given, a minus sign is added to the +// front. If width is given, the two's complement of the number is +// returned, with respect to that width. +// +// In a two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit two's-complement +// system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// num : int +// Only an integer decimal number can be used. +// width : int, optional +// The length of the returned string if `num` is positive, or the length +// of the two's complement if `num` is negative, provided that `width` is +// at least a sufficient number of bits for `num` to be represented in the +// designated form. +// +// If the `width` value is insufficient, it will be ignored, and `num` will +// be returned in binary (`num` > 0) or two's complement (`num` < 0) form +// with its width equal to the minimum number of bits needed to represent +// the number in the designated form. This behavior is deprecated and will +// later raise an error. +// +// .. deprecated:: 1.12.0 +// +// Returns +// ------- +// bin : str +// Binary representation of `num` or two's complement of `num`. +// +// See Also +// -------- +// base_repr: Return a string representation of a number in the given base +// system. +// bin: Python's built-in binary representation generator of an integer. +// +// Notes +// ----- +// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x +// faster. +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// >>> np.binary_repr(3) +// '11' +// >>> np.binary_repr(-3) +// '-11' +// >>> np.binary_repr(3, width=4) +// '0011' +// +// The two's complement is returned when the input number is negative and +// width is specified: +// +// >>> np.binary_repr(-3, width=3) +// '101' +// >>> np.binary_repr(-3, width=5) +// '11101' +// +// +// +//go:linkname BinaryRepr py.binary_repr +func BinaryRepr(num *py.Object, width *py.Object) *py.Object +// +// Return a string representation of a number in the given base system. +// +// Parameters +// ---------- +// number : int +// The value to convert. Positive and negative values are handled. +// base : int, optional +// Convert `number` to the `base` number system. The valid range is 2-36, +// the default value is 2. +// padding : int, optional +// Number of zeros padded on the left. Default is 0 (no padding). +// +// Returns +// ------- +// out : str +// String representation of `number` in `base` system. +// +// See Also +// -------- +// binary_repr : Faster version of `base_repr` for base 2. +// +// Examples +// -------- +// >>> np.base_repr(5) +// '101' +// >>> np.base_repr(6, 5) +// '11' +// >>> np.base_repr(7, base=5, padding=3) +// '00012' +// +// >>> np.base_repr(10, base=16) +// 'A' +// >>> np.base_repr(32, base=16) +// '20' +// +// +// +//go:linkname BaseRepr py.base_repr +func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object +// +// Return a new array of given shape and type, filled with ones. +// +// Parameters +// ---------- +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// dtype : data-type, optional +// The desired data-type for the array, e.g., `numpy.int8`. Default is +// `numpy.float64`. +// order : {'C', 'F'}, optional, default: C +// Whether to store multi-dimensional data in row-major +// (C-style) or column-major (Fortran-style) order in +// memory. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of ones with the given shape, dtype, and order. +// +// See Also +// -------- +// ones_like : Return an array of ones with shape and type of input. +// empty : Return a new uninitialized array. +// zeros : Return a new array setting values to zero. +// full : Return a new array of given shape filled with value. +// +// +// Examples +// -------- +// >>> np.ones(5) +// array([1., 1., 1., 1., 1.]) +// +// >>> np.ones((5,), dtype=int) +// array([1, 1, 1, 1, 1]) +// +// >>> np.ones((2, 1)) +// array([[1.], +// [1.]]) +// +// >>> s = (2,2) +// >>> np.ones(s) +// array([[1., 1.], +// [1., 1.]]) +// +// +// +//go:linkname Ones py.ones +func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// Return the identity array. +// +// The identity array is a square array with ones on +// the main diagonal. +// +// Parameters +// ---------- +// n : int +// Number of rows (and columns) in `n` x `n` output. +// dtype : data-type, optional +// Data-type of the output. Defaults to ``float``. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// `n` x `n` array with its main diagonal set to one, +// and all other elements 0. +// +// Examples +// -------- +// >>> np.identity(3) +// array([[1., 0., 0.], +// [0., 1., 0.], +// [0., 0., 1.]]) +// +// +// +//go:linkname Identity py.identity +func Identity(n *py.Object, dtype *py.Object) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. +// +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: +// +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' +// +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) +// +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) +// +//go:linkname BitwiseNot py.bitwise_not +func BitwiseNot(__llgo_va_list ...interface{}) *py.Object +// +// Return a new array of given shape and type, filled with `fill_value`. +// +// Parameters +// ---------- +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// fill_value : scalar or array_like +// Fill value. +// dtype : data-type, optional +// The desired data-type for the array The default, None, means +// ``np.array(fill_value).dtype``. +// order : {'C', 'F'}, optional +// Whether to store multidimensional data in C- or Fortran-contiguous +// (row- or column-wise) order in memory. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of `fill_value` with the given shape, dtype, and order. +// +// See Also +// -------- +// full_like : Return a new array with shape of input filled with value. +// empty : Return a new uninitialized array. +// ones : Return a new array setting values to one. +// zeros : Return a new array setting values to zero. +// +// Examples +// -------- +// >>> np.full((2, 2), np.inf) +// array([[inf, inf], +// [inf, inf]]) +// >>> np.full((2, 2), 10) +// array([[10, 10], +// [10, 10]]) +// +// >>> np.full((2, 2), [1, 2]) +// array([[1, 2], +// [1, 2]]) +// +// +// +//go:linkname Full py.full +func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object +// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) +// +// Matrix product of two arrays. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays, scalars not allowed. +// out : ndarray, optional +// A location into which the result is stored. If provided, it must have +// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not +// provided or None, a freshly-allocated array is returned. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// .. versionadded:: 1.16 +// Now handles ufunc kwargs +// +// Returns +// ------- +// y : ndarray +// The matrix product of the inputs. +// This is a scalar only when both x1, x2 are 1-d vectors. +// +// Raises +// ------ +// ValueError +// If the last dimension of `x1` is not the same size as +// the second-to-last dimension of `x2`. +// +// If a scalar value is passed in. +// +// See Also +// -------- +// vdot : Complex-conjugating dot product. +// tensordot : Sum products over arbitrary axes. +// einsum : Einstein summation convention. +// dot : alternative matrix product with different broadcasting rules. +// +// Notes +// ----- +// +// The behavior depends on the arguments in the following way. +// +// - If both arguments are 2-D they are multiplied like conventional +// matrices. +// - If either argument is N-D, N > 2, it is treated as a stack of +// matrices residing in the last two indexes and broadcast accordingly. +// - If the first argument is 1-D, it is promoted to a matrix by +// prepending a 1 to its dimensions. After matrix multiplication +// the prepended 1 is removed. +// - If the second argument is 1-D, it is promoted to a matrix by +// appending a 1 to its dimensions. After matrix multiplication +// the appended 1 is removed. +// +// ``matmul`` differs from ``dot`` in two important ways: +// +// - Multiplication by scalars is not allowed, use ``*`` instead. +// - Stacks of matrices are broadcast together as if the matrices +// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: +// +// >>> a = np.ones([9, 5, 7, 4]) +// >>> c = np.ones([9, 5, 4, 3]) +// >>> np.dot(a, c).shape +// (9, 5, 7, 9, 5, 3) +// >>> np.matmul(a, c).shape +// (9, 5, 7, 3) +// >>> # n is 7, k is 4, m is 3 +// +// The matmul function implements the semantics of the ``@`` operator +// introduced in Python 3.5 following :pep:`465`. +// +// It uses an optimized BLAS library when possible (see `numpy.linalg`). +// +// Examples +// -------- +// For 2-D arrays it is the matrix product: +// +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([[4, 1], +// ... [2, 2]]) +// >>> np.matmul(a, b) +// array([[4, 1], +// [2, 2]]) +// +// For 2-D mixed with 1-D, the result is the usual. +// +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([1, 2]) +// >>> np.matmul(a, b) +// array([1, 2]) +// >>> np.matmul(b, a) +// array([1, 2]) +// +// +// Broadcasting is conventional for stacks of arrays +// +// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) +// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) +// >>> np.matmul(a,b).shape +// (2, 2, 2) +// >>> np.matmul(a, b)[0, 1, 1] +// 98 +// >>> sum(a[0, 1, :] * b[0 , :, 1]) +// 98 +// +// Vector, vector returns the scalar inner product, but neither argument +// is complex-conjugated: +// +// >>> np.matmul([2j, 3j], [2j, 3j]) +// (-13+0j) +// +// Scalar multiplication raises an error. +// +// >>> np.matmul([1,2], 3) +// Traceback (most recent call last): +// ... +// ValueError: matmul: Input operand 1 does not have enough dimensions ... +// +// The ``@`` operator can be used as a shorthand for ``np.matmul`` on +// ndarrays. +// +// >>> x1 = np.array([2j, 3j]) +// >>> x2 = np.array([2j, 3j]) +// >>> x1 @ x2 +// (-13+0j) +// +// .. versionadded:: 1.10.0 +// +//go:linkname Matmul py.matmul +func Matmul(__llgo_va_list ...interface{}) *py.Object +// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the absolute value element-wise. +// +// ``np.abs`` is a shorthand for this function. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// absolute : ndarray +// An ndarray containing the absolute value of +// each element in `x`. For complex input, ``a + ib``, the +// absolute value is :math:`\sqrt{ a^2 + b^2 }`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> x = np.array([-1.2, 1.2]) +// >>> np.absolute(x) +// array([ 1.2, 1.2]) +// >>> np.absolute(1.2 + 1j) +// 1.5620499351813308 +// +// Plot the function over ``[-10, 10]``: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(start=-10, stop=10, num=101) +// >>> plt.plot(x, np.absolute(x)) +// >>> plt.show() +// +// Plot the function over the complex plane: +// +// >>> xx = x + 1j * x[:, np.newaxis] +// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') +// >>> plt.show() +// +// The `abs` function can be used as a shorthand for ``np.absolute`` on +// ndarrays. +// +// >>> x = np.array([-1.2, 1.2]) +// >>> abs(x) +// array([1.2, 1.2]) +// +//go:linkname Absolute py.absolute +func Absolute(__llgo_va_list ...interface{}) *py.Object +// add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Add arguments element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays to be added. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// add : ndarray or scalar +// The sum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to `x1` + `x2` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.add(1.0, 4.0) +// 5.0 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.add(x1, x2) +// array([[ 0., 2., 4.], +// [ 3., 5., 7.], +// [ 6., 8., 10.]]) +// +// The ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 + x2 +// array([[ 0., 2., 4.], +// [ 3., 5., 7.], +// [ 6., 8., 10.]]) +// +//go:linkname Add py.add +func Add(__llgo_va_list ...interface{}) *py.Object +// arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric inverse cosine, element-wise. +// +// The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``. +// +// Parameters +// ---------- +// x : array_like +// `x`-coordinate on the unit circle. +// For real arguments, the domain is [-1, 1]. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// The angle of the ray intersecting the unit circle at the given +// `x`-coordinate in radians [0, pi]. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// cos, arctan, arcsin, emath.arccos +// +// Notes +// ----- +// `arccos` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``cos(z) = x``. The convention is to return +// the angle `z` whose real part lies in `[0, pi]`. +// +// For real-valued input data types, `arccos` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse `cos` is also known as `acos` or cos^-1. +// +// References +// ---------- +// M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// We expect the arccos of 1 to be 0, and of -1 to be pi: +// +// >>> np.arccos([1, -1]) +// array([ 0. , 3.14159265]) +// +// Plot arccos: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-1, 1, num=100) +// >>> plt.plot(x, np.arccos(x)) +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Arccos py.arccos +func Arccos(__llgo_va_list ...interface{}) *py.Object +// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic cosine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// arccosh : ndarray +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// +// cosh, arcsinh, sinh, arctanh, tanh +// +// Notes +// ----- +// `arccosh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `cosh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in +// ``[0, inf]``. +// +// For real-valued input data types, `arccosh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `arccosh` is a complex analytical function that +// has a branch cut `[-inf, 1]` and is continuous from above on it. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arccosh +// +// Examples +// -------- +// >>> np.arccosh([np.e, 10.0]) +// array([ 1.65745445, 2.99322285]) +// >>> np.arccosh(1) +// 0.0 +// +//go:linkname Arccosh py.arccosh +func Arccosh(__llgo_va_list ...interface{}) *py.Object +// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse sine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// `y`-coordinate on the unit circle. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// The inverse sine of each element in `x`, in radians and in the +// closed interval ``[-pi/2, pi/2]``. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin +// +// Notes +// ----- +// `arcsin` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that :math:`sin(z) = x`. The convention is to +// return the angle `z` whose real part lies in [-pi/2, pi/2]. +// +// For real-valued input data types, *arcsin* always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse sine is also known as `asin` or sin^{-1}. +// +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79ff. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// >>> np.arcsin(1) # pi/2 +// 1.5707963267948966 +// >>> np.arcsin(-1) # -pi/2 +// -1.5707963267948966 +// >>> np.arcsin(0) +// 0.0 +// +//go:linkname Arcsin py.arcsin +func Arcsin(__llgo_va_list ...interface{}) *py.Object +// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic sine element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `arcsinh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `sinh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// +// For real-valued input data types, `arcsinh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// returns ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arcsinh +// +// Examples +// -------- +// >>> np.arcsinh(np.array([np.e, 10.0])) +// array([ 1.72538256, 2.99822295]) +// +//go:linkname Arcsinh py.arcsinh +func Arcsinh(__llgo_va_list ...interface{}) *py.Object +// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric inverse tangent, element-wise. +// +// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. +// +// Parameters +// ---------- +// x : array_like +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Out has the same shape as `x`. Its real part is in +// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) +// and the positive `x`-axis. +// angle : Argument of complex values. +// +// Notes +// ----- +// `arctan` is a multi-valued function: for each `x` there are infinitely +// many numbers `z` such that tan(`z`) = `x`. The convention is to return +// the angle `z` whose real part lies in [-pi/2, pi/2]. +// +// For real-valued input data types, `arctan` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse tangent is also known as `atan` or tan^{-1}. +// +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// We expect the arctan of 0 to be 0, and of 1 to be pi/4: +// +// >>> np.arctan([0, 1]) +// array([ 0. , 0.78539816]) +// +// >>> np.pi/4 +// 0.78539816339744828 +// +// Plot arctan: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-10, 10) +// >>> plt.plot(x, np.arctan(x)) +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Arctan py.arctan +func Arctan(__llgo_va_list ...interface{}) *py.Object +// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. +// +// 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`). (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). +// +// This function is not defined for complex-valued arguments; for the +// so-called argument of complex values, use `angle`. +// +// Parameters +// ---------- +// x1 : array_like, real-valued +// `y`-coordinates. +// x2 : array_like, real-valued +// `x`-coordinates. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// Array of angles in radians, in the range ``[-pi, pi]``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// arctan, tan, angle +// +// Notes +// ----- +// *arctan2* is identical to the `atan2` function of the underlying +// C library. The following special values are defined in the C +// standard: [1]_ +// +// ====== ====== ================ +// `x1` `x2` `arctan2(x1,x2)` +// ====== ====== ================ +// +/- 0 +0 +/- 0 +// +/- 0 -0 +/- pi +// > 0 +/-inf +0 / +pi +// < 0 +/-inf -0 / -pi +// +/-inf +inf +/- (pi/4) +// +/-inf -inf +/- (3*pi/4) +// ====== ====== ================ +// +// Note that +0 and -0 are distinct floating point numbers, as are +inf +// and -inf. +// +// References +// ---------- +// .. [1] ISO/IEC standard 9899:1999, "Programming language C." +// +// Examples +// -------- +// Consider four points in different quadrants: +// +// >>> x = np.array([-1, +1, +1, -1]) +// >>> y = np.array([-1, -1, +1, +1]) +// >>> np.arctan2(y, x) * 180 / np.pi +// array([-135., -45., 45., 135.]) +// +// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 +// and at several other special points, obtaining values in +// the range ``[-pi, pi]``: +// +// >>> np.arctan2([1., -1.], [0., 0.]) +// array([ 1.57079633, -1.57079633]) +// >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) +// array([0. , 3.14159265, 0.78539816]) +// +//go:linkname Arctan2 py.arctan2 +func Arctan2(__llgo_va_list ...interface{}) *py.Object +// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic tangent element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.arctanh +// +// Notes +// ----- +// `arctanh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``tanh(z) = x``. The convention is to return +// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// +// For real-valued input data types, `arctanh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arctanh +// +// Examples +// -------- +// >>> np.arctanh([0, -0.5]) +// array([ 0. , -0.54930614]) +// +//go:linkname Arctanh py.arctanh +func Arctanh(__llgo_va_list ...interface{}) *py.Object +// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise AND of two arrays element-wise. +// +// Computes the bit-wise AND of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``&``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and +// bitwise_or +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise AND of 13 and 17 is +// therefore ``000000001``, or 1: +// +// >>> np.bitwise_and(13, 17) +// 1 +// +// >>> np.bitwise_and(14, 13) +// 12 +// >>> np.binary_repr(12) +// '1100' +// >>> np.bitwise_and([14,3], 13) +// array([12, 1]) +// +// >>> np.bitwise_and([11,7], [4,25]) +// array([0, 1]) +// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) +// array([ 2, 4, 16]) +// >>> np.bitwise_and([True, True], [False, True]) +// array([False, True]) +// +// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([3, 14, 16]) +// >>> x1 & x2 +// array([ 2, 4, 16]) +// +//go:linkname BitwiseAnd py.bitwise_and +func BitwiseAnd(__llgo_va_list ...interface{}) *py.Object +// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise OR of two arrays element-wise. +// +// Computes the bit-wise OR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``|``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or +// bitwise_and +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 has the binary representation ``00001101``. Likewise, +// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is +// then ``00011101``, or 29: +// +// >>> np.bitwise_or(13, 16) +// 29 +// >>> np.binary_repr(29) +// '11101' +// +// >>> np.bitwise_or(32, 2) +// 34 +// >>> np.bitwise_or([33, 4], 1) +// array([33, 5]) +// >>> np.bitwise_or([33, 4], [1, 2]) +// array([33, 6]) +// +// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) +// array([ 6, 5, 255]) +// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) +// array([ 6, 5, 255]) +// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), +// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) +// array([ 6, 5, 255, 2147483647]) +// >>> np.bitwise_or([True, True], [False, True]) +// array([ True, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([4, 4, 4]) +// >>> x1 | x2 +// array([ 6, 5, 255]) +// +//go:linkname BitwiseOr py.bitwise_or +func BitwiseOr(__llgo_va_list ...interface{}) *py.Object +// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise XOR of two arrays element-wise. +// +// Computes the bit-wise XOR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``^``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_xor +// bitwise_and +// bitwise_or +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise XOR of 13 and 17 is +// therefore ``00011100``, or 28: +// +// >>> np.bitwise_xor(13, 17) +// 28 +// >>> np.binary_repr(28) +// '11100' +// +// >>> np.bitwise_xor(31, 5) +// 26 +// >>> np.bitwise_xor([31,3], 5) +// array([26, 6]) +// +// >>> np.bitwise_xor([31,3], [5,6]) +// array([26, 5]) +// >>> np.bitwise_xor([True, True], [False, True]) +// array([ True, False]) +// +// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on +// ndarrays. +// +// >>> x1 = np.array([True, True]) +// >>> x2 = np.array([False, True]) +// >>> x1 ^ x2 +// array([ True, False]) +// +//go:linkname BitwiseXor py.bitwise_xor +func BitwiseXor(__llgo_va_list ...interface{}) *py.Object +// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the cube-root of an array, element-wise. +// +// .. versionadded:: 1.10.0 +// +// Parameters +// ---------- +// x : array_like +// The values whose cube-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the cube +// cube-root of each element in `x`. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. +// +// +// Examples +// -------- +// >>> np.cbrt([1,8,27]) +// array([ 1., 2., 3.]) +// +//go:linkname Cbrt py.cbrt +func Cbrt(__llgo_va_list ...interface{}) *py.Object +// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the ceiling of the input, element-wise. +// +// The ceil of the scalar `x` is the smallest integer `i`, such that +// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The ceiling of each element in `x`, with `float` dtype. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// floor, trunc, rint, fix +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.ceil(a) +// array([-1., -1., -0., 1., 2., 2., 2.]) +// +//go:linkname Ceil py.ceil +func Ceil(__llgo_va_list ...interface{}) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conj py.conj +func Conj(__llgo_va_list ...interface{}) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conjugate py.conjugate +func Conjugate(__llgo_va_list ...interface{}) *py.Object +// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Change the sign of x1 to that of x2, element-wise. +// +// If `x2` is a scalar, its sign will be copied to all elements of `x1`. +// +// Parameters +// ---------- +// x1 : array_like +// Values to change the sign of. +// x2 : array_like +// The sign of `x2` is copied to `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The values of `x1` with the sign of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.copysign(1.3, -1) +// -1.3 +// >>> 1/np.copysign(0, 1) +// inf +// >>> 1/np.copysign(0, -1) +// -inf +// +// >>> np.copysign([-1, 0, 1], -1.1) +// array([-1., -0., -1.]) +// >>> np.copysign([-1, 0, 1], np.arange(3)-1) +// array([-1., 0., 1.]) +// +//go:linkname Copysign py.copysign +func Copysign(__llgo_va_list ...interface{}) *py.Object +// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Cosine element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding cosine values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. +// +// Examples +// -------- +// >>> np.cos(np.array([0, np.pi/2, np.pi])) +// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) +// >>> +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Cos py.cos +func Cos(__llgo_va_list ...interface{}) *py.Object +// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Hyperbolic cosine, element-wise. +// +// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array of same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.cosh(0) +// 1.0 +// +// The hyperbolic cosine describes the shape of a hanging cable: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-4, 4, 1000) +// >>> plt.plot(x, np.cosh(x)) +// >>> plt.show() +// +//go:linkname Cosh py.cosh +func Cosh(__llgo_va_list ...interface{}) *py.Object +// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Angles in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in radians. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : Convert angles from radians to degrees. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// ``deg2rad(x)`` is ``x * pi / 180``. +// +// Examples +// -------- +// >>> np.deg2rad(180) +// 3.1415926535897931 +// +//go:linkname Deg2rad py.deg2rad +func Deg2rad(__llgo_va_list ...interface{}) *py.Object +// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. +// +// Parameters +// ---------- +// x : array_like +// Input array in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray of floats +// The corresponding degree values; if `out` was supplied this is a +// reference to it. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : equivalent function +// +// Examples +// -------- +// Convert a radian array to degrees +// +// >>> rad = np.arange(12.)*np.pi/6 +// >>> np.degrees(rad) +// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., +// 270., 300., 330.]) +// +// >>> out = np.zeros((rad.shape)) +// >>> r = np.degrees(rad, out) +// >>> np.all(r == out) +// True +// +//go:linkname Degrees py.degrees +func Degrees(__llgo_va_list ...interface{}) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. +// +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. +// +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.divide(x1, x2) +// array([[nan, 1. , 1. ], +// [inf, 4. , 2.5], +// [inf, 7. , 4. ]]) +// +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) +// +//go:linkname Divide py.divide +func Divide(__llgo_va_list ...interface{}) *py.Object +// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return element-wise quotient and remainder simultaneously. +// +// .. versionadded:: 1.13.0 +// +// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster +// because it avoids redundant work. It is used to implement the Python +// built-in function ``divmod`` on NumPy arrays. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out1 : ndarray +// Element-wise quotient resulting from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// out2 : ndarray +// Element-wise remainder from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent to Python's ``//`` operator. +// remainder : Equivalent to Python's ``%`` operator. +// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return +// values switched. +// +// Examples +// -------- +// >>> np.divmod(np.arange(5), 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// +// The `divmod` function can be used as a shorthand for ``np.divmod`` on +// ndarrays. +// +// >>> x = np.arange(5) +// >>> divmod(x, 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// +//go:linkname Divmod py.divmod +func Divmod(__llgo_va_list ...interface{}) *py.Object +// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return (x1 == x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// not_equal, greater_equal, less_equal, greater, less +// +// Examples +// -------- +// >>> np.equal([0, 1, 3], np.arange(3)) +// array([ True, True, False]) +// +// What is compared are values, not types. So an int (1) and an array of +// length one can evaluate as True: +// +// >>> np.equal(1, np.ones(1)) +// array([ True]) +// +// The ``==`` operator can be used as a shorthand for ``np.equal`` on +// ndarrays. +// +// >>> a = np.array([2, 4, 6]) +// >>> b = np.array([2, 4, 2]) +// >>> a == b +// array([ True, True, False]) +// +//go:linkname Equal py.equal +func Equal(__llgo_va_list ...interface{}) *py.Object +// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the exponential of all elements in the input array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array, element-wise exponential of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. +// exp2 : Calculate ``2**x`` for all elements in the array. +// +// Notes +// ----- +// The irrational number ``e`` is also known as Euler's number. It is +// approximately 2.718281, and is the base of the natural logarithm, +// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, +// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. +// +// For complex arguments, ``x = a + ib``, we can write +// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already +// known (it is the real argument, described above). The second term, +// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with +// magnitude 1 and a periodic phase. +// +// References +// ---------- +// .. [1] Wikipedia, "Exponential function", +// https://en.wikipedia.org/wiki/Exponential_function +// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions +// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, +// https://personal.math.ubc.ca/~cbm/aands/page_69.htm +// +// Examples +// -------- +// Plot the magnitude and phase of ``exp(x)`` in the complex plane: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) +// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane +// >>> out = np.exp(xx) +// +// >>> plt.subplot(121) +// >>> plt.imshow(np.abs(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') +// >>> plt.title('Magnitude of exp(x)') +// +// >>> plt.subplot(122) +// >>> plt.imshow(np.angle(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') +// >>> plt.title('Phase (angle) of exp(x)') +// >>> plt.show() +// +//go:linkname Exp py.exp +func Exp(__llgo_va_list ...interface{}) *py.Object +// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate `2**p` for all `p` in the input array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise 2 to the power `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// power +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// +// +// Examples +// -------- +// >>> np.exp2([2, 3]) +// array([ 4., 8.]) +// +//go:linkname Exp2 py.exp2 +func Exp2(__llgo_va_list ...interface{}) *py.Object +// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate ``exp(x) - 1`` for all elements in the array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise exponential minus one: ``out = exp(x) - 1``. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log1p : ``log(1 + x)``, the inverse of expm1. +// +// +// Notes +// ----- +// This function provides greater precision than ``exp(x) - 1`` +// for small values of ``x``. +// +// Examples +// -------- +// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to +// about 32 significant digits. This example shows the superiority of +// expm1 in this case. +// +// >>> np.expm1(1e-10) +// 1.00000000005e-10 +// >>> np.exp(1e-10) - 1 +// 1.000000082740371e-10 +// +//go:linkname Expm1 py.expm1 +func Expm1(__llgo_va_list ...interface{}) *py.Object +// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the absolute values element-wise. +// +// This function returns the absolute values (positive magnitude) of the +// data in `x`. Complex values are not handled, use `absolute` to find the +// absolute values of complex data. +// +// Parameters +// ---------- +// x : array_like +// The array of numbers for which the absolute values are required. If +// `x` is a scalar, the result `y` will also be a scalar. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The absolute values of `x`, the returned values are always floats. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// absolute : Absolute values including `complex` types. +// +// Examples +// -------- +// >>> np.fabs(-1) +// 1.0 +// >>> np.fabs([-1.2, 1.2]) +// array([ 1.2, 1.2]) +// +//go:linkname Fabs py.fabs +func Fabs(__llgo_va_list ...interface{}) *py.Object +// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the floor of the input, element-wise. +// +// The floor of the scalar `x` is the largest integer `i`, such that +// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The floor of each element in `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ceil, trunc, rint, fix +// +// Notes +// ----- +// Some spreadsheet programs calculate the "floor-towards-zero", where +// ``floor(-2.5) == -2``. NumPy instead uses the definition of +// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" +// function is called ``fix`` in NumPy. +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.floor(a) +// array([-2., -2., -1., 0., 1., 1., 2.]) +// +//go:linkname Floor py.floor +func Floor(__llgo_va_list ...interface{}) *py.Object +// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the largest integer smaller or equal to the division of the inputs. +// It is equivalent to the Python ``//`` operator and pairs with the +// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` +// up to roundoff. +// +// Parameters +// ---------- +// x1 : array_like +// Numerator. +// x2 : array_like +// Denominator. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// y = floor(`x1`/`x2`) +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// remainder : Remainder complementary to floor_divide. +// divmod : Simultaneous floor division and remainder. +// divide : Standard division. +// floor : Round a number to the nearest integer toward minus infinity. +// ceil : Round a number to the nearest integer toward infinity. +// +// Examples +// -------- +// >>> np.floor_divide(7,3) +// 2 +// >>> np.floor_divide([1., 2., 3., 4.], 2.5) +// array([ 0., 0., 1., 1.]) +// +// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` +// on ndarrays. +// +// >>> x1 = np.array([1., 2., 3., 4.]) +// >>> x1 // 2.5 +// array([0., 0., 1., 1.]) +// +//go:linkname FloorDivide py.floor_divide +func FloorDivide(__llgo_va_list ...interface{}) *py.Object +// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// First array elements raised to powers from second array, element-wise. +// +// Raise each base in `x1` to the positionally-corresponding power in `x2`. +// `x1` and `x2` must be broadcastable to the same shape. This differs from +// the power function in that integers, float16, and float32 are promoted to +// floats with a minimum precision of float64 so that the result is always +// inexact. The intent is that the function will return a usable result for +// negative powers and seldom overflow for positive powers. +// +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). +// +// .. versionadded:: 1.12.0 +// +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// power : power function that preserves type +// +// Examples +// -------- +// Cube each element in a list. +// +// >>> x1 = range(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.float_power(x1, 3) +// array([ 0., 1., 8., 27., 64., 125.]) +// +// Raise the bases to different exponents. +// +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.float_power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) +// +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.float_power(x1, x2) +// array([[ 0., 1., 8., 27., 16., 5.], +// [ 0., 1., 8., 27., 16., 5.]]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1, -4]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.float_power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.float_power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname FloatPower py.float_power +func FloatPower(__llgo_va_list ...interface{}) *py.Object +// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise maximum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// minimum, amin, nanmin +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// +// Examples +// -------- +// >>> np.fmax([2, 3, 4], [1, 5, 2]) +// array([ 2., 5., 4.]) +// +// >>> np.fmax(np.eye(2), [0.5, 2]) +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) +// +//go:linkname Fmax py.fmax +func Fmax(__llgo_va_list ...interface{}) *py.Object +// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise minimum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// maximum, amax, nanmax +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// +// Examples +// -------- +// >>> np.fmin([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) +// +// >>> np.fmin(np.eye(2), [0.5, 2]) +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) +// +// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) +// +//go:linkname Fmin py.fmin +func Fmin(__llgo_va_list ...interface{}) *py.Object +// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// This is the NumPy implementation of the C library function fmod, the +// remainder has the same sign as the dividend `x1`. It is equivalent to +// the Matlab(TM) ``rem`` function and should not be confused with the +// Python modulus operator ``x1 % x2``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend. +// x2 : array_like +// Divisor. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : array_like +// The remainder of the division of `x1` by `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// remainder : Equivalent to the Python ``%`` operator. +// divide +// +// Notes +// ----- +// The result of the modulo operation for negative dividend and divisors +// is bound by conventions. For `fmod`, the sign of result is the sign of +// the dividend, while for `remainder` the sign of the result is the sign +// of the divisor. The `fmod` function is equivalent to the Matlab(TM) +// ``rem`` function. +// +// Examples +// -------- +// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) +// array([-1, 0, -1, 1, 0, 1]) +// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) +// array([1, 0, 1, 1, 0, 1]) +// +// >>> np.fmod([5, 3], [2, 2.]) +// array([ 1., 1.]) +// >>> a = np.arange(-3, 3).reshape(3, 2) +// >>> a +// array([[-3, -2], +// [-1, 0], +// [ 1, 2]]) +// >>> np.fmod(a, [2,2]) +// array([[-1, 0], +// [-1, 0], +// [ 1, 0]]) +// +//go:linkname Fmod py.fmod +func Fmod(__llgo_va_list ...interface{}) *py.Object +// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Decompose the elements of x into mantissa and twos exponent. +// +// Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``. +// The mantissa lies in the open interval(-1, 1), while the twos +// exponent is a signed integer. +// +// Parameters +// ---------- +// x : array_like +// Array of numbers to be decomposed. +// out1 : ndarray, optional +// Output array for the mantissa. Must have the same shape as `x`. +// out2 : ndarray, optional +// Output array for the exponent. Must have the same shape as `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// mantissa : ndarray +// Floating values between -1 and 1. +// This is a scalar if `x` is a scalar. +// exponent : ndarray +// Integer exponents of 2. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`. +// +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. +// +// Examples +// -------- +// >>> x = np.arange(9) +// >>> y1, y2 = np.frexp(x) +// >>> y1 +// array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, +// 0.5 ]) +// >>> y2 +// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) +// >>> y1 * 2**y2 +// array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) +// +//go:linkname Frexp py.frexp +func Frexp(__llgo_va_list ...interface{}) *py.Object +// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the Heaviside step function. +// +// The Heaviside step function is defined as:: +// +// 0 if x1 < 0 +// heaviside(x1, x2) = x2 if x1 == 0 +// 1 if x1 > 0 +// +// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. +// +// Parameters +// ---------- +// x1 : array_like +// Input values. +// x2 : array_like +// The value of the function when x1 is 0. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The output array, element-wise Heaviside step function of `x1`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// .. versionadded:: 1.13.0 +// +// References +// ---------- +// .. Wikipedia, "Heaviside step function", +// https://en.wikipedia.org/wiki/Heaviside_step_function +// +// Examples +// -------- +// >>> np.heaviside([-1.5, 0, 2.0], 0.5) +// array([ 0. , 0.5, 1. ]) +// >>> np.heaviside([-1.5, 0, 2.0], 1) +// array([ 0., 1., 1.]) +// +//go:linkname Heaviside py.heaviside +func Heaviside(__llgo_va_list ...interface{}) *py.Object +// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Given the "legs" of a right triangle, return its hypotenuse. +// +// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. 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. +// (See Examples) +// +// Parameters +// ---------- +// x1, x2 : array_like +// Leg of the triangle(s). +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// z : ndarray +// The hypotenuse of the triangle(s). +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) +// +// Example showing broadcast of scalar_like argument: +// +// >>> np.hypot(3*np.ones((3, 3)), [4]) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) +// +//go:linkname Hypot py.hypot +func Hypot(__llgo_va_list ...interface{}) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. +// +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: +// +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' +// +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) +// +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) +// +//go:linkname Invert py.invert +func Invert(__llgo_va_list ...interface{}) *py.Object +// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for finiteness (not infinity and not Not a Number). +// +// The result is returned as a boolean array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray, bool +// True where ``x`` is not positive infinity, negative infinity, +// or NaN; false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isinf, isneginf, isposinf, isnan +// +// 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. +// +// Examples +// -------- +// >>> np.isfinite(1) +// True +// >>> np.isfinite(0) +// True +// >>> np.isfinite(np.nan) +// False +// >>> np.isfinite(np.inf) +// False +// >>> np.isfinite(np.NINF) +// False +// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) +// array([False, True, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isfinite(x, y) +// array([0, 1, 0]) +// >>> y +// array([0, 1, 0]) +// +//go:linkname Isfinite py.isfinite +func Isfinite(__llgo_va_list ...interface{}) *py.Object +// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for positive or negative infinity. +// +// Returns a boolean array of the same shape as `x`, True where ``x == +// +/-inf``, otherwise False. +// +// Parameters +// ---------- +// x : array_like +// Input values +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool (scalar) or boolean ndarray +// True where ``x`` is positive or negative infinity, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isneginf, isposinf, isnan, isfinite +// +// 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. +// +// Examples +// -------- +// >>> np.isinf(np.inf) +// True +// >>> np.isinf(np.nan) +// False +// >>> np.isinf(np.NINF) +// True +// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) +// array([ True, True, False, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isinf(x, y) +// array([1, 0, 1]) +// >>> y +// array([1, 0, 1]) +// +//go:linkname Isinf py.isinf +func Isinf(__llgo_va_list ...interface{}) *py.Object +// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for NaN and return result as a boolean array. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaN, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isinf, isneginf, isposinf, isfinite, isnat +// +// 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. +// +// Examples +// -------- +// >>> np.isnan(np.nan) +// True +// >>> np.isnan(np.inf) +// False +// >>> np.isnan([np.log(-1.),1.,np.log(0)]) +// array([ True, False, False]) +// +//go:linkname Isnan py.isnan +func Isnan(__llgo_va_list ...interface{}) *py.Object +// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for NaT (not a time) and return result as a boolean array. +// +// .. versionadded:: 1.13.0 +// +// Parameters +// ---------- +// x : array_like +// Input array with datetime or timedelta data type. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaT, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isnan, isinf, isneginf, isposinf, isfinite +// +// Examples +// -------- +// >>> np.isnat(np.datetime64("NaT")) +// True +// >>> np.isnat(np.datetime64("2016-01-01")) +// False +// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) +// array([ True, False]) +// +//go:linkname Isnat py.isnat +func Isnat(__llgo_va_list ...interface{}) *py.Object +// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` +// +// Parameters +// ---------- +// x1, x2 : array_like, int +// Arrays of values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// +// Returns +// ------- +// y : ndarray or scalar +// The lowest common multiple of the absolute value of the inputs +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// gcd : The greatest common divisor +// +// Examples +// -------- +// >>> np.lcm(12, 20) +// 60 +// >>> np.lcm.reduce([3, 12, 20]) +// 60 +// >>> np.lcm.reduce([40, 12, 20]) +// 120 +// >>> np.lcm(np.arange(6), 20) +// array([ 0, 20, 20, 60, 20, 20]) +// +//go:linkname Lcm py.lcm +func Lcm(__llgo_va_list ...interface{}) *py.Object +// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns x1 * 2**x2, element-wise. +// +// The mantissas `x1` and twos exponents `x2` are used to construct +// floating point numbers ``x1 * 2**x2``. +// +// Parameters +// ---------- +// x1 : array_like +// Array of multipliers. +// x2 : array_like, int +// Array of twos exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The result of ``x1 * 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. +// +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. +// +// `ldexp` is useful as the inverse of `frexp`, if used by itself it is +// more clear to simply use the expression ``x1 * 2**x2``. +// +// Examples +// -------- +// >>> np.ldexp(5, np.arange(4)) +// array([ 5., 10., 20., 40.], dtype=float16) +// +// >>> x = np.arange(6) +// >>> np.ldexp(*np.frexp(x)) +// array([ 0., 1., 2., 3., 4., 5.]) +// +//go:linkname Ldexp py.ldexp +func Ldexp(__llgo_va_list ...interface{}) *py.Object +// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Shift the bits of an integer to the left. +// +// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. +// Since the internal representation of numbers is in binary format, this +// operation is equivalent to multiplying `x1` by ``2**x2``. +// +// Parameters +// ---------- +// x1 : array_like of integer type +// Input values. +// x2 : array_like of integer type +// Number of zeros to append to `x1`. Has to be non-negative. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : array of integer type +// Return `x1` with bits shifted `x2` times to the left. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// right_shift : Shift the bits of an integer to the right. +// binary_repr : Return the binary representation of the input number +// as a string. +// +// Examples +// -------- +// >>> np.binary_repr(5) +// '101' +// >>> np.left_shift(5, 2) +// 20 +// >>> np.binary_repr(20) +// '10100' +// +// >>> np.left_shift(5, [1,2,3]) +// array([10, 20, 40]) +// +// Note that the dtype of the second argument may change the dtype of the +// result and can lead to unexpected results in some cases (see +// :ref:`Casting Rules `): +// +// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 +// >>> print(a, type(a)) # Unexpected result due to upcasting +// 510 +// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) +// >>> print(b, type(b)) +// 254 +// +// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on +// ndarrays. +// +// >>> x1 = 5 +// >>> x2 = np.array([1, 2, 3]) +// >>> x1 << x2 +// array([10, 20, 40]) +// +//go:linkname LeftShift py.left_shift +func LeftShift(__llgo_va_list ...interface{}) *py.Object +// less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 < x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// greater, less_equal, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less([1, 2], [2, 2]) +// array([ True, False]) +// +// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. +// +// >>> a = np.array([1, 2]) +// >>> b = np.array([2, 2]) +// >>> a < b +// array([ True, False]) +// +//go:linkname Less py.less +func Less(__llgo_va_list ...interface{}) *py.Object +// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 <= x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// greater, less, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less_equal([4, 2, 1], [2, 2, 2]) +// array([False, True, True]) +// +// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on +// ndarrays. +// +// >>> a = np.array([4, 2, 1]) +// >>> b = np.array([2, 2, 2]) +// >>> a <= b +// array([False, True, True]) +// +//go:linkname LessEqual py.less_equal +func LessEqual(__llgo_va_list ...interface{}) *py.Object +// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Natural logarithm, element-wise. +// +// The natural logarithm `log` is the inverse of the exponential function, +// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base +// `e`. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The natural logarithm of `x`, element-wise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log10, log2, log1p, emath.log +// +// Notes +// ----- +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log` always returns real output. For +// each value that cannot be expressed as a real number or infinity, it +// yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log([1, np.e, np.e**2, 0]) +// array([ 0., 1., 2., -Inf]) +// +//go:linkname Log py.log +func Log(__llgo_va_list ...interface{}) *py.Object +// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the base 10 logarithm of the input array, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The logarithm to the base 10 of `x`, element-wise. NaNs are +// returned where x is negative. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.log10 +// +// Notes +// ----- +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `10**z = x`. The convention is to return the +// `z` whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log10` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log10` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. +// `log10` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log10([1e-15, -3.]) +// array([-15., nan]) +// +//go:linkname Log10 py.log10 +func Log10(__llgo_va_list ...interface{}) *py.Object +// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the natural logarithm of one plus the input array, element-wise. +// +// Calculates ``log(1 + x)``. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Natural logarithm of `1 + x`, element-wise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// expm1 : ``exp(x) - 1``, the inverse of `log1p`. +// +// Notes +// ----- +// For real-valued input, `log1p` is accurate also for `x` so small +// that `1 + x == 1` in floating-point accuracy. +// +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = 1 + x`. The convention is to return +// the `z` whose imaginary part lies in `[-pi, pi]`. +// +// For real-valued input data types, `log1p` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log1p` is a complex analytical function that +// has a branch cut `[-inf, -1]` and is continuous from above on it. +// `log1p` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log1p(1e-99) +// 1e-99 +// >>> np.log(1 + 1e-99) +// 0.0 +// +//go:linkname Log1p py.log1p +func Log1p(__llgo_va_list ...interface{}) *py.Object +// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Base-2 logarithm of `x`. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Base-2 logarithm of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log, log10, log1p, emath.log2 +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `2**z = x`. The convention is to return the `z` +// whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log2` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log2` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// Examples +// -------- +// >>> x = np.array([0, 1, 2, 2**4]) +// >>> np.log2(x) +// array([-Inf, 0., 1., 4.]) +// +// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) +// >>> np.log2(xi) +// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) +// +//go:linkname Log2 py.log2 +func Log2(__llgo_va_list ...interface{}) *py.Object +// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Logarithm of the sum of exponentiations of the inputs. +// +// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in +// statistics where the calculated probabilities of events may be so small +// as to exceed the range of normal floating point numbers. In such cases +// the logarithm of the calculated probability is stored. This function +// allows adding probabilities stored in such a fashion. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray +// Logarithm of ``exp(x1) + exp(x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> prob1 = np.log(1e-50) +// >>> prob2 = np.log(2.5e-50) +// >>> prob12 = np.logaddexp(prob1, prob2) +// >>> prob12 +// -113.87649168120691 +// >>> np.exp(prob12) +// 3.5000000000000057e-50 +// +//go:linkname Logaddexp py.logaddexp +func Logaddexp(__llgo_va_list ...interface{}) *py.Object +// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Logarithm of the sum of exponentiations of the inputs in base-2. +// +// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine +// learning when the calculated probabilities of events may be so small as +// to exceed the range of normal floating point numbers. In such cases +// the base-2 logarithm of the calculated probability can be used instead. +// This function allows adding probabilities stored in such a fashion. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray +// Base-2 logarithm of ``2**x1 + 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logaddexp: Logarithm of the sum of exponentiations of the inputs. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> prob1 = np.log2(1e-50) +// >>> prob2 = np.log2(2.5e-50) +// >>> prob12 = np.logaddexp2(prob1, prob2) +// >>> prob1, prob2, prob12 +// (-166.09640474436813, -164.77447664948076, -164.28904982231052) +// >>> 2**prob12 +// 3.4999999999999914e-50 +// +//go:linkname Logaddexp2 py.logaddexp2 +func Logaddexp2(__llgo_va_list ...interface{}) *py.Object +// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 AND x2 element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// Boolean result of the logical AND operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or, logical_not, logical_xor +// bitwise_and +// +// Examples +// -------- +// >>> np.logical_and(True, False) +// False +// >>> np.logical_and([True, False], [False, False]) +// array([False, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_and(x>1, x<4) +// array([False, False, True, True, False]) +// +// +// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on +// boolean ndarrays. +// +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a & b +// array([False, False]) +// +//go:linkname LogicalAnd py.logical_and +func LogicalAnd(__llgo_va_list ...interface{}) *py.Object +// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of NOT x element-wise. +// +// Parameters +// ---------- +// x : array_like +// Logical NOT is applied to the elements of `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool or ndarray of bool +// 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. +// +// See Also +// -------- +// logical_and, logical_or, logical_xor +// +// Examples +// -------- +// >>> np.logical_not(3) +// False +// >>> np.logical_not([True, False, 0, 1]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_not(x<3) +// array([False, False, False, True, True]) +// +//go:linkname LogicalNot py.logical_not +func LogicalNot(__llgo_va_list ...interface{}) *py.Object +// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 OR x2 element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Logical OR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// Boolean result of the logical OR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and, logical_not, logical_xor +// bitwise_or +// +// Examples +// -------- +// >>> np.logical_or(True, False) +// True +// >>> np.logical_or([True, False], [False, False]) +// array([ True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_or(x < 1, x > 3) +// array([ True, False, False, False, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on +// boolean ndarrays. +// +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a | b +// array([ True, False]) +// +//go:linkname LogicalOr py.logical_or +func LogicalOr(__llgo_va_list ...interface{}) *py.Object +// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 XOR x2, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Logical XOR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool or ndarray of bool +// Boolean result of the logical XOR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and, logical_or, logical_not, bitwise_xor +// +// Examples +// -------- +// >>> np.logical_xor(True, False) +// True +// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_xor(x < 1, x > 3) +// array([ True, False, False, False, True]) +// +// Simple example showing support of broadcasting +// +// >>> np.logical_xor(0, np.eye(2)) +// array([[ True, False], +// [False, True]]) +// +//go:linkname LogicalXor py.logical_xor +func LogicalXor(__llgo_va_list ...interface{}) *py.Object +// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise maximum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// fmin, amin, nanmin +// +// Notes +// ----- +// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when +// neither x1 nor x2 are nans, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.maximum([2, 3, 4], [1, 5, 2]) +// array([2, 5, 4]) +// +// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.maximum(np.Inf, 1) +// inf +// +//go:linkname Maximum py.maximum +func Maximum(__llgo_va_list ...interface{}) *py.Object +// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise minimum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// fmax, amax, nanmax +// +// Notes +// ----- +// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when +// neither x1 nor x2 are NaNs, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.minimum([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) +// +// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) +// +// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.minimum(-np.Inf, 1) +// -inf +// +//go:linkname Minimum py.minimum +func Minimum(__llgo_va_list ...interface{}) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. +// +// .. warning:: +// +// This should not be confused with: +// +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor +// +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. +// +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) +// +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Mod py.mod +func Mod(__llgo_va_list ...interface{}) *py.Object +// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the fractional and integral parts of an array, element-wise. +// +// The fractional and integral parts are negative if the given number is +// negative. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y1 : ndarray +// Fractional part of `x`. +// This is a scalar if `x` is a scalar. +// y2 : ndarray +// Integral part of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// For integer input the return values are floats. +// +// See Also +// -------- +// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values +// switched, except it always has a positive remainder. +// +// Examples +// -------- +// >>> np.modf([0, 3.5]) +// (array([ 0. , 0.5]), array([ 0., 3.])) +// >>> np.modf(-0.5) +// (-0.5, -0) +// +//go:linkname Modf py.modf +func Modf(__llgo_va_list ...interface{}) *py.Object +// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Multiply arguments element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays to be multiplied. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The product of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to `x1` * `x2` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.multiply(2.0, 4.0) +// 8.0 +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.multiply(x1, x2) +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) +// +// The ``*`` operator can be used as a shorthand for ``np.multiply`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 * x2 +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) +// +//go:linkname Multiply py.multiply +func Multiply(__llgo_va_list ...interface{}) *py.Object +// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Numerical negative, element-wise. +// +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = -x`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.negative([1.,-1.]) +// array([-1., 1.]) +// +// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on +// ndarrays. +// +// >>> x1 = np.array(([1., -1.])) +// >>> -x1 +// array([-1., 1.]) +// +//go:linkname Negative py.negative +func Negative(__llgo_va_list ...interface{}) *py.Object +// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the next floating-point value after x1 towards x2, element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Values to find the next representable value of. +// x2 : array_like +// The direction where to look for the next representable value of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The next representable values of `x1` in the direction of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> eps = np.finfo(np.float64).eps +// >>> np.nextafter(1, 2) == eps + 1 +// True +// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] +// array([ True, True]) +// +//go:linkname Nextafter py.nextafter +func Nextafter(__llgo_va_list ...interface{}) *py.Object +// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return (x1 != x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// equal, greater, greater_equal, less, less_equal +// +// Examples +// -------- +// >>> np.not_equal([1.,2.], [1., 3.]) +// array([False, True]) +// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) +// array([[False, True], +// [False, True]]) +// +// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on +// ndarrays. +// +// >>> a = np.array([1., 2.]) +// >>> b = np.array([1., 3.]) +// >>> a != b +// array([False, True]) +// +//go:linkname NotEqual py.not_equal +func NotEqual(__llgo_va_list ...interface{}) *py.Object +// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Numerical positive, element-wise. +// +// .. versionadded:: 1.13.0 +// +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = +x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// Equivalent to `x.copy()`, but only defined for types that support +// arithmetic. +// +// Examples +// -------- +// +// >>> x1 = np.array(([1., -1.])) +// >>> np.positive(x1) +// array([ 1., -1.]) +// +// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on +// ndarrays. +// +// >>> x1 = np.array(([1., -1.])) +// >>> +x1 +// array([ 1., -1.]) +// +//go:linkname Positive py.positive +func Positive(__llgo_va_list ...interface{}) *py.Object +// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// First array elements raised to powers from second array, element-wise. +// +// Raise each base in `x1` to the positionally-corresponding power in +// `x2`. `x1` and `x2` must be broadcastable to the same shape. +// +// An integer type raised to a negative integer power will raise a +// ``ValueError``. +// +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). +// +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// float_power : power function that promotes integers to float +// +// Examples +// -------- +// Cube each element in an array. +// +// >>> x1 = np.arange(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.power(x1, 3) +// array([ 0, 1, 8, 27, 64, 125]) +// +// Raise the bases to different exponents. +// +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) +// +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.power(x1, x2) +// array([[ 0, 1, 8, 27, 16, 5], +// [ 0, 1, 8, 27, 16, 5]]) +// +// The ``**`` operator can be used as a shorthand for ``np.power`` on +// ndarrays. +// +// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) +// >>> x1 = np.arange(6) +// >>> x1 ** x2 +// array([ 0, 1, 8, 27, 16, 5]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1.0, -4.0]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname Power py.power +func Power(__llgo_va_list ...interface{}) *py.Object +// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. +// +// Parameters +// ---------- +// x : array_like +// Angle in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in degrees. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// deg2rad : Convert angles from degrees to radians. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// rad2deg(x) is ``180 * x / pi``. +// +// Examples +// -------- +// >>> np.rad2deg(np.pi/2) +// 90.0 +// +//go:linkname Rad2deg py.rad2deg +func Rad2deg(__llgo_va_list ...interface{}) *py.Object +// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Input array in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding radian values. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// deg2rad : equivalent function +// +// Examples +// -------- +// Convert a degree array to radians +// +// >>> deg = np.arange(12.) * 30. +// >>> np.radians(deg) +// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , +// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, +// 5.23598776, 5.75958653]) +// +// >>> out = np.zeros((deg.shape)) +// >>> ret = np.radians(deg, out) +// >>> ret is out +// True +// +//go:linkname Radians py.radians +func Radians(__llgo_va_list ...interface{}) *py.Object +// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the reciprocal of the argument, element-wise. +// +// Calculates ``1/x``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Return array. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// .. note:: +// This function is not designed to work with integers. +// +// For integer arguments with absolute value larger than 1 the result is +// always zero because of the way Python handles integer division. For +// integer zero the result is an overflow. +// +// Examples +// -------- +// >>> np.reciprocal(2.) +// 0.5 +// >>> np.reciprocal([1, 2., 3.33]) +// array([ 1. , 0.5 , 0.3003003]) +// +//go:linkname Reciprocal py.reciprocal +func Reciprocal(__llgo_va_list ...interface{}) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. +// +// .. warning:: +// +// This should not be confused with: +// +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor +// +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. +// +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) +// +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Remainder py.remainder +func Remainder(__llgo_va_list ...interface{}) *py.Object +// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Shift the bits of an integer to the right. +// +// Bits are shifted to the right `x2`. Because the internal +// representation of numbers is in binary format, this operation is +// equivalent to dividing `x1` by ``2**x2``. +// +// Parameters +// ---------- +// x1 : array_like, int +// Input values. +// x2 : array_like, int +// Number of bits to remove at the right of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray, int +// Return `x1` with bits shifted `x2` times to the right. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// left_shift : Shift the bits of an integer to the left. +// binary_repr : Return the binary representation of the input number +// as a string. +// +// Examples +// -------- +// >>> np.binary_repr(10) +// '1010' +// >>> np.right_shift(10, 1) +// 5 +// >>> np.binary_repr(5) +// '101' +// +// >>> np.right_shift(10, [1,2,3]) +// array([5, 2, 1]) +// +// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on +// ndarrays. +// +// >>> x1 = 10 +// >>> x2 = np.array([1,2,3]) +// >>> x1 >> x2 +// array([5, 2, 1]) +// +//go:linkname RightShift py.right_shift +func RightShift(__llgo_va_list ...interface{}) *py.Object +// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Round elements of the array to the nearest integer. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array is same shape and type as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// fix, ceil, floor, trunc +// +// Notes +// ----- +// For values exactly halfway between rounded decimal values, NumPy +// rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, +// -0.5 and 0.5 round to 0.0, etc. +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.rint(a) +// array([-2., -2., -0., 0., 2., 2., 2.]) +// +//go:linkname Rint py.rint +func Rint(__llgo_va_list ...interface{}) *py.Object +// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns an element-wise indication of the sign of a number. +// +// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan +// is returned for nan inputs. +// +// For complex inputs, the `sign` function returns +// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. +// +// complex(nan, 0) is returned for complex nan inputs. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The sign of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// There is more than one definition of sign in common use for complex +// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` +// which is different from a common alternative, :math:`x/|x|`. +// +// Examples +// -------- +// >>> np.sign([-5., 4.5]) +// array([-1., 1.]) +// >>> np.sign(0) +// 0 +// >>> np.sign(5-2j) +// (1+0j) +// +//go:linkname Sign py.sign +func Sign(__llgo_va_list ...interface{}) *py.Object +// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns element-wise True where signbit is set (less than zero). +// +// Parameters +// ---------- +// x : array_like +// The input value(s). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray of bool +// Output array, or reference to `out` if that was supplied. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.signbit(-1.2) +// True +// >>> np.signbit(np.array([1, -2.3, 2.1])) +// array([False, True, False]) +// +//go:linkname Signbit py.signbit +func Signbit(__llgo_va_list ...interface{}) *py.Object +// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric sine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : array_like +// The sine of each element of x. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// arcsin, sinh, cos +// +// Notes +// ----- +// The sine is one of the fundamental functions of trigonometry (the +// mathematical study of triangles). Consider a circle of radius 1 +// centered on the origin. A ray comes in from the :math:`+x` axis, makes +// an angle at the origin (measured counter-clockwise from that axis), and +// departs from the origin. The :math:`y` coordinate of the outgoing +// ray's intersection with the unit circle is the sine of that angle. It +// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The +// function has zeroes where the angle is a multiple of :math:`\pi`. +// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. +// The numerous properties of the sine and related functions are included +// in any standard trigonometry text. +// +// Examples +// -------- +// Print sine of one angle: +// +// >>> np.sin(np.pi/2.) +// 1.0 +// +// Print sines of an array of angles given in degrees: +// +// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) +// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) +// +// Plot the sine function: +// +// >>> import matplotlib.pylab as plt +// >>> x = np.linspace(-np.pi, np.pi, 201) +// >>> plt.plot(x, np.sin(x)) +// >>> plt.xlabel('Angle [rad]') +// >>> plt.ylabel('sin(x)') +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Sin py.sin +func Sin(__llgo_va_list ...interface{}) *py.Object +// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Hyperbolic sine, element-wise. +// +// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or +// ``-1j * np.sin(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding hyperbolic sine values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// +// Examples +// -------- +// >>> np.sinh(0) +// 0.0 +// >>> np.sinh(np.pi*1j/2) +// 1j +// >>> np.sinh(np.pi*1j) # (exact value is 0) +// 1.2246063538223773e-016j +// >>> # Discrepancy due to vagaries of floating point arithmetic. +// +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.sinh([0.1], out1) +// >>> out2 is out1 +// True +// +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Sinh py.sinh +func Sinh(__llgo_va_list ...interface{}) *py.Object +// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the distance between x and the nearest adjacent number. +// +// Parameters +// ---------- +// x : array_like +// Values to find the spacing of. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The spacing of values of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// It can be considered as a generalization of EPS: +// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there +// should not be any representable number between ``x + spacing(x)`` and +// x for any finite x. +// +// Spacing of +- inf and NaN is NaN. +// +// Examples +// -------- +// >>> np.spacing(1) == np.finfo(np.float64).eps +// True +// +//go:linkname Spacing py.spacing +func Spacing(__llgo_va_list ...interface{}) *py.Object +// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the non-negative square-root of an array, element-wise. +// +// Parameters +// ---------- +// x : array_like +// The values whose square-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the positive +// square-root of each element in `x`. If any element in `x` is +// complex, a complex array is returned (and the square-roots of +// negative reals are calculated). If all of the elements in `x` +// are real, so is `y`, with negative elements returning ``nan``. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.sqrt +// A version which returns complex numbers when given negative reals. +// Note that 0.0 and -0.0 are handled differently for complex inputs. +// +// Notes +// ----- +// *sqrt* has--consistent with common convention--as its branch cut the +// real "interval" [`-inf`, 0), and is continuous from above on it. +// A branch cut is a curve in the complex plane across which a given +// complex function fails to be continuous. +// +// Examples +// -------- +// >>> np.sqrt([1,4,9]) +// array([ 1., 2., 3.]) +// +// >>> np.sqrt([4, -1, -3+4J]) +// array([ 2.+0.j, 0.+1.j, 1.+2.j]) +// +// >>> np.sqrt([4, -1, np.inf]) +// array([ 2., nan, inf]) +// +//go:linkname Sqrt py.sqrt +func Sqrt(__llgo_va_list ...interface{}) *py.Object +// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the element-wise square of the input. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise `x*x`, of the same shape and dtype as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// numpy.linalg.matrix_power +// sqrt +// power +// +// Examples +// -------- +// >>> np.square([-1j, 1]) +// array([-1.-0.j, 1.+0.j]) +// +//go:linkname Square py.square +func Square(__llgo_va_list ...interface{}) *py.Object +// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Subtract arguments, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays to be subtracted from each other. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The difference of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to ``x1 - x2`` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.subtract(1.0, 4.0) +// -3.0 +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.subtract(x1, x2) +// array([[ 0., 0., 0.], +// [ 3., 3., 3.], +// [ 6., 6., 6.]]) +// +// The ``-`` operator can be used as a shorthand for ``np.subtract`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 - x2 +// array([[0., 0., 0.], +// [3., 3., 3.], +// [6., 6., 6.]]) +// +//go:linkname Subtract py.subtract +func Subtract(__llgo_va_list ...interface{}) *py.Object +// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute tangent element-wise. +// +// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding tangent values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. +// +// Examples +// -------- +// >>> from math import pi +// >>> np.tan(np.array([-pi,pi/2,pi])) +// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) +// >>> +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Tan py.tan +func Tan(__llgo_va_list ...interface{}) *py.Object +// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute hyperbolic tangent element-wise. +// +// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding hyperbolic tangent values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// https://personal.math.ubc.ca/~cbm/aands/page_83.htm +// +// .. [2] Wikipedia, "Hyperbolic function", +// https://en.wikipedia.org/wiki/Hyperbolic_function +// +// Examples +// -------- +// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) +// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) +// +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.tanh([0.1], out1) +// >>> out2 is out1 +// True +// +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Tanh py.tanh +func Tanh(__llgo_va_list ...interface{}) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. +// +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. +// +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.divide(x1, x2) +// array([[nan, 1. , 1. ], +// [inf, 4. , 2.5], +// [inf, 7. , 4. ]]) +// +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) +// +//go:linkname TrueDivide py.true_divide +func TrueDivide(__llgo_va_list ...interface{}) *py.Object +// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truncated value of the input, element-wise. +// +// The truncated value of the scalar `x` is the nearest integer `i` which +// is closer to zero than `x` is. In short, the fractional part of the +// signed number `x` is discarded. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The truncated value of each element in `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ceil, floor, rint, fix +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.trunc(a) +// array([-1., -1., -0., 0., 1., 1., 2.]) +// +//go:linkname Trunc py.trunc +func Trunc(__llgo_va_list ...interface{}) *py.Object +// +// Return the scalar dtype or NumPy equivalent of Python type of an object. +// +// Parameters +// ---------- +// rep : any +// The object of which the type is returned. +// default : any, optional +// If given, this is returned for objects whose types can not be +// determined. If not given, None is returned for those objects. +// +// Returns +// ------- +// dtype : dtype or Python type +// The data type of `rep`. +// +// See Also +// -------- +// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype +// +// Examples +// -------- +// >>> np.obj2sctype(np.int32) +// +// >>> np.obj2sctype(np.array([1., 2.])) +// +// >>> np.obj2sctype(np.array([1.j])) +// +// +// >>> np.obj2sctype(dict) +// +// >>> np.obj2sctype('string') +// +// >>> np.obj2sctype(1, default=list) +// +// +// +// +//go:linkname Obj2sctype py.obj2sctype +func Obj2sctype(rep *py.Object, default_ *py.Object) *py.Object +// +// Return the string representation of a scalar dtype. +// +// Parameters +// ---------- +// sctype : scalar dtype or object +// If a scalar dtype, the corresponding string character is +// returned. If an object, `sctype2char` tries to infer its scalar type +// and then return the corresponding string character. +// +// Returns +// ------- +// typechar : str +// The string character corresponding to the scalar type. +// +// Raises +// ------ +// ValueError +// If `sctype` is an object for which the type can not be inferred. +// +// See Also +// -------- +// obj2sctype, issctype, issubsctype, mintypecode +// +// Examples +// -------- +// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: +// ... print(np.sctype2char(sctype)) +// l # may vary +// d +// D +// S +// O +// +// >>> x = np.array([1., 2-1.j]) +// >>> np.sctype2char(x) +// 'D' +// >>> np.sctype2char(list) +// 'O' +// +// +// +//go:linkname Sctype2char py.sctype2char +func Sctype2char(sctype *py.Object) *py.Object +// +// Return the scalar type of highest precision of the same kind as the input. +// +// Parameters +// ---------- +// t : dtype or dtype specifier +// The input data type. This can be a `dtype` object or an object that +// is convertible to a `dtype`. +// +// Returns +// ------- +// out : dtype +// The highest precision data type of the same kind (`dtype.kind`) as `t`. +// +// See Also +// -------- +// obj2sctype, mintypecode, sctype2char +// dtype +// +// Examples +// -------- +// >>> np.maximum_sctype(int) +// +// >>> np.maximum_sctype(np.uint8) +// +// >>> np.maximum_sctype(complex) +// # may vary +// +// >>> np.maximum_sctype(str) +// +// +// >>> np.maximum_sctype('i2') +// +// >>> np.maximum_sctype('f4') +// # may vary +// +// +// +//go:linkname MaximumSctype py.maximum_sctype +func MaximumSctype(t *py.Object) *py.Object +// +// Determines whether the given object represents a scalar data-type. +// +// Parameters +// ---------- +// rep : any +// If `rep` is an instance of a scalar dtype, True is returned. If not, +// False is returned. +// +// Returns +// ------- +// out : bool +// Boolean result of check whether `rep` is a scalar dtype. +// +// See Also +// -------- +// issubsctype, issubdtype, obj2sctype, sctype2char +// +// Examples +// -------- +// >>> np.issctype(np.int32) +// True +// >>> np.issctype(list) +// False +// >>> np.issctype(1.1) +// False +// +// Strings are also a scalar type: +// +// >>> np.issctype(np.dtype('str')) +// True +// +// +// +//go:linkname Issctype py.issctype +func Issctype(rep *py.Object) *py.Object +// +// Determine common type following standard coercion rules. +// +// .. deprecated:: NumPy 1.25 +// +// This function is deprecated, use `numpy.promote_types` or +// `numpy.result_type` instead. To achieve semantics for the +// `scalar_types` argument, use `numpy.result_type` and pass the Python +// values `0`, `0.0`, or `0j`. +// This will give the same results in almost all cases. +// More information and rare exception can be found in the +// `NumPy 1.25 release notes `_. +// +// Parameters +// ---------- +// array_types : sequence +// A list of dtypes or dtype convertible objects representing arrays. +// scalar_types : sequence +// A list of dtypes or dtype convertible objects representing scalars. +// +// Returns +// ------- +// datatype : dtype +// The common data type, which is the maximum of `array_types` ignoring +// `scalar_types`, unless the maximum of `scalar_types` is of a +// different kind (`dtype.kind`). If the kind is not understood, then +// None is returned. +// +// See Also +// -------- +// dtype, common_type, can_cast, mintypecode +// +// Examples +// -------- +// >>> np.find_common_type([], [np.int64, np.float32, complex]) +// dtype('complex128') +// >>> np.find_common_type([np.int64, np.float32], []) +// dtype('float64') +// +// The standard casting rules ensure that a scalar cannot up-cast an +// array unless the scalar is of a fundamentally different kind of data +// (i.e. under a different hierarchy in the data type hierarchy) then +// the array: +// +// >>> np.find_common_type([np.float32], [np.int64, np.float64]) +// dtype('float32') +// +// Complex is of a different type, so it up-casts the float in the +// `array_types` argument: +// +// >>> np.find_common_type([np.float32], [complex]) +// dtype('complex128') +// +// Type specifier strings are convertible to dtypes and can therefore +// be used instead of dtypes: +// +// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) +// dtype('complex128') +// +// +// +//go:linkname FindCommonType py.find_common_type +func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object +// +// Returns True if first argument is a typecode lower/equal in type hierarchy. +// +// This is like the builtin :func:`issubclass`, but for `dtype`\ s. +// +// Parameters +// ---------- +// arg1, arg2 : dtype_like +// `dtype` or object coercible to one +// +// Returns +// ------- +// out : bool +// +// See Also +// -------- +// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. +// issubsctype, issubclass_ +// +// Examples +// -------- +// `issubdtype` can be used to check the type of arrays: +// +// >>> ints = np.array([1, 2, 3], dtype=np.int32) +// >>> np.issubdtype(ints.dtype, np.integer) +// True +// >>> np.issubdtype(ints.dtype, np.floating) +// False +// +// >>> floats = np.array([1, 2, 3], dtype=np.float32) +// >>> np.issubdtype(floats.dtype, np.integer) +// False +// >>> np.issubdtype(floats.dtype, np.floating) +// True +// +// Similar types of different sizes are not subdtypes of each other: +// +// >>> np.issubdtype(np.float64, np.float32) +// False +// >>> np.issubdtype(np.float32, np.float64) +// False +// +// but both are subtypes of `floating`: +// +// >>> np.issubdtype(np.float64, np.floating) +// True +// >>> np.issubdtype(np.float32, np.floating) +// True +// +// For convenience, dtype-like objects are allowed too: +// +// >>> np.issubdtype('S1', np.string_) +// True +// >>> np.issubdtype('i4', np.signedinteger) +// True +// +// +// +//go:linkname Issubdtype py.issubdtype +func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Set a Python function to be used when pretty printing arrays. +// +// Parameters +// ---------- +// f : function or None +// Function to be used to pretty print arrays. The function should expect +// a single array argument and return a string of the representation of +// the array. If None, the function is reset to the default NumPy function +// to print arrays. +// repr : bool, optional +// If True (default), the function for pretty printing (``__repr__``) +// is set, if False the function that returns the default string +// representation (``__str__``) is set. +// +// See Also +// -------- +// set_printoptions, get_printoptions +// +// Examples +// -------- +// >>> def pprint(arr): +// ... return 'HA! - What are you going to do now?' +// ... +// >>> np.set_string_function(pprint) +// >>> a = np.arange(10) +// >>> a +// HA! - What are you going to do now? +// >>> _ = a +// >>> # [0 1 2 3 4 5 6 7 8 9] +// +// We can reset the function to the default: +// +// >>> np.set_string_function(None) +// >>> a +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// +// `repr` affects either pretty printing or normal string representation. +// Note that ``__repr__`` is still affected by setting ``__str__`` +// because the width of each array element in the returned string becomes +// equal to the length of the result of ``__str__()``. +// +// >>> x = np.arange(4) +// >>> np.set_string_function(lambda x:'random', repr=False) +// >>> x.__str__() +// 'random' +// >>> x.__repr__() +// 'array([0, 1, 2, 3])' +// +// +// +//go:linkname SetStringFunction py.set_string_function +func SetStringFunction(f *py.Object, repr *py.Object) *py.Object +// +// Set printing options. +// +// These options determine the way floating point numbers, arrays and +// other NumPy objects are displayed. +// +// Parameters +// ---------- +// precision : int or None, optional +// Number of digits of precision for floating point output (default 8). +// May be None if `floatmode` is not `fixed`, to print as many digits as +// necessary to uniquely specify the value. +// threshold : int, optional +// Total number of array elements which trigger summarization +// rather than full repr (default 1000). +// To always use the full repr without summarization, pass `sys.maxsize`. +// edgeitems : int, optional +// Number of array items in summary at beginning and end of +// each dimension (default 3). +// linewidth : int, optional +// The number of characters per line for the purpose of inserting +// line breaks (default 75). +// suppress : bool, optional +// If True, always print floating point numbers using fixed point +// notation, in which case numbers equal to zero in the current precision +// will print as zero. If False, then scientific notation is used when +// absolute value of the smallest number is < 1e-4 or the ratio of the +// maximum absolute value to the minimum is > 1e3. The default is False. +// nanstr : str, optional +// String representation of floating point not-a-number (default nan). +// infstr : str, optional +// String representation of floating point infinity (default inf). +// sign : string, either '-', '+', or ' ', optional +// Controls printing of the sign of floating-point types. If '+', always +// print the sign of positive values. If ' ', always prints a space +// (whitespace character) in the sign position of positive values. If +// '-', omit the sign character of positive values. (default '-') +// formatter : dict of callables, optional +// If not None, the keys should indicate the type(s) that the respective +// formatting function applies to. Callables should return a string. +// Types that are not specified (by their corresponding keys) are handled +// by the default formatters. Individual types for which a formatter +// can be set are: +// +// - 'bool' +// - 'int' +// - 'timedelta' : a `numpy.timedelta64` +// - 'datetime' : a `numpy.datetime64` +// - 'float' +// - 'longfloat' : 128-bit floats +// - 'complexfloat' +// - 'longcomplexfloat' : composed of two 128-bit floats +// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` +// - 'object' : `np.object_` arrays +// +// Other keys that can be used to set a group of types at once are: +// +// - 'all' : sets all types +// - 'int_kind' : sets 'int' +// - 'float_kind' : sets 'float' and 'longfloat' +// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' +// - 'str_kind' : sets 'numpystr' +// floatmode : str, optional +// Controls the interpretation of the `precision` option for +// floating-point types. Can take the following values +// (default maxprec_equal): +// +// * 'fixed': Always print exactly `precision` fractional digits, +// even if this would print more or fewer digits than +// necessary to specify the value uniquely. +// * 'unique': Print the minimum number of fractional digits necessary +// to represent each value uniquely. Different elements may +// have a different number of digits. The value of the +// `precision` option is ignored. +// * 'maxprec': Print at most `precision` fractional digits, but if +// an element can be uniquely represented with fewer digits +// only print it with that many. +// * 'maxprec_equal': Print at most `precision` fractional digits, +// but if every element in the array can be uniquely +// represented with an equal number of fewer digits, use that +// many digits for all elements. +// legacy : string or `False`, optional +// If set to the string `'1.13'` enables 1.13 legacy printing mode. This +// approximates numpy 1.13 print output by including a space in the sign +// position of floats and different behavior for 0d arrays. This also +// enables 1.21 legacy printing mode (described below). +// +// If set to the string `'1.21'` enables 1.21 legacy printing mode. This +// approximates numpy 1.21 print output of complex structured dtypes +// by not inserting spaces after commas that separate fields and after +// colons. +// +// If set to `False`, disables legacy mode. +// +// Unrecognized strings will be ignored with a warning for forward +// compatibility. +// +// .. versionadded:: 1.14.0 +// .. versionchanged:: 1.22.0 +// +// See Also +// -------- +// get_printoptions, printoptions, set_string_function, array2string +// +// Notes +// ----- +// `formatter` is always reset with a call to `set_printoptions`. +// +// Use `printoptions` as a context manager to set the values temporarily. +// +// Examples +// -------- +// Floating point precision can be set: +// +// >>> np.set_printoptions(precision=4) +// >>> np.array([1.123456789]) +// [1.1235] +// +// Long arrays can be summarised: +// +// >>> np.set_printoptions(threshold=5) +// >>> np.arange(10) +// array([0, 1, 2, ..., 7, 8, 9]) +// +// Small results can be suppressed: +// +// >>> eps = np.finfo(float).eps +// >>> x = np.arange(4.) +// >>> x**2 - (x + eps)**2 +// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) +// >>> np.set_printoptions(suppress=True) +// >>> x**2 - (x + eps)**2 +// array([-0., -0., 0., 0.]) +// +// A custom formatter can be used to display array elements as desired: +// +// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) +// >>> x = np.arange(3) +// >>> x +// array([int: 0, int: -1, int: -2]) +// >>> np.set_printoptions() # formatter gets reset +// >>> x +// array([0, 1, 2]) +// +// To put back the default options, you can use: +// +// >>> np.set_printoptions(edgeitems=3, infstr='inf', +// ... linewidth=75, nanstr='nan', precision=8, +// ... suppress=False, threshold=1000, formatter=None) +// +// Also to temporarily override options, use `printoptions` as a context manager: +// +// >>> with np.printoptions(precision=2, suppress=True, threshold=5): +// ... np.linspace(0, 10, 10) +// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) +// +// +// +//go:linkname SetPrintoptions py.set_printoptions +func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object +// +// Return the current print options. +// +// Returns +// ------- +// print_opts : dict +// Dictionary of current print options with keys +// +// - precision : int +// - threshold : int +// - edgeitems : int +// - linewidth : int +// - suppress : bool +// - nanstr : str +// - infstr : str +// - formatter : dict of callables +// - sign : str +// +// For a full description of these options, see `set_printoptions`. +// +// See Also +// -------- +// set_printoptions, printoptions, set_string_function +// +// +// +//go:linkname GetPrintoptions py.get_printoptions +func GetPrintoptions() *py.Object +// Context manager for setting print options. +// +// Set print options for the scope of the `with` block, and restore the old +// options at the end. See `set_printoptions` for the full description of +// available options. +// +// Examples +// -------- +// +// >>> from numpy.testing import assert_equal +// >>> with np.printoptions(precision=2): +// ... np.array([2.0]) / 3 +// array([0.67]) +// +// The `as`-clause of the `with`-statement gives the current print options: +// +// >>> with np.printoptions(precision=2) as opts: +// ... assert_equal(opts, np.get_printoptions()) +// +// See Also +// -------- +// set_printoptions, get_printoptions +// +// +// +//go:linkname Printoptions py.printoptions +func Printoptions(__llgo_va_list ...interface{}) *py.Object +// +// Format a floating-point scalar as a decimal string in positional notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed, or if `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// fractional : boolean, optional +// If `True`, the cutoffs of `precision` and `min_digits` refer to the +// total number of digits after the decimal point, including leading +// zeros. +// If `False`, `precision` and `min_digits` refer to the total number of +// significant digits, before or after the decimal point, ignoring leading +// zeros. +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// pad_right : non-negative integer, optional +// Pad the right side of the string with whitespace until at least that +// many characters are to the right of the decimal point. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. Only has an effect if `unique=True` +// in which case additional digits past those necessary to uniquely +// identify the value may be printed, rounding the last additional digit. +// +// -- versionadded:: 1.21.0 +// +// Returns +// ------- +// rep : string +// The string representation of the floating point value +// +// See Also +// -------- +// format_float_scientific +// +// Examples +// -------- +// >>> np.format_float_positional(np.float32(np.pi)) +// '3.1415927' +// >>> np.format_float_positional(np.float16(np.pi)) +// '3.14' +// >>> np.format_float_positional(np.float16(0.3)) +// '0.3' +// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) +// '0.3000488281' +// +// +//go:linkname FormatFloatPositional py.format_float_positional +func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object +// +// Format a floating-point scalar as a decimal string in scientific notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed. If `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// exp_digits : non-negative integer, optional +// Pad the exponent with zeros until it contains at least this many digits. +// If omitted, the exponent will be at least 2 digits. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. This only has an effect for +// `unique=True`. In that case more digits than necessary to uniquely +// identify the value may be printed and rounded unbiased. +// +// -- versionadded:: 1.21.0 +// +// Returns +// ------- +// rep : string +// The string representation of the floating point value +// +// See Also +// -------- +// format_float_positional +// +// Examples +// -------- +// >>> np.format_float_scientific(np.float32(np.pi)) +// '3.1415927e+00' +// >>> s = np.float32(1.23e24) +// >>> np.format_float_scientific(s, unique=False, precision=15) +// '1.230000071797338e+24' +// >>> np.format_float_scientific(s, exp_digits=4) +// '1.23e+0024' +// +// +//go:linkname FormatFloatScientific py.format_float_scientific +func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object +// +// Return an ndarray of the provided type that satisfies requirements. +// +// This function is useful to be sure that an array with the correct flags +// is returned for passing to compiled code (perhaps through ctypes). +// +// Parameters +// ---------- +// a : array_like +// The object to be converted to a type-and-requirement-satisfying array. +// dtype : data-type +// The required data-type. If None preserve the current dtype. If your +// application requires the data to be in native byteorder, include +// a byteorder specification as a part of the dtype specification. +// requirements : str or sequence of str +// The requirements list can be any of the following +// +// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array +// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array +// * 'ALIGNED' ('A') - ensure a data-type aligned array +// * 'WRITEABLE' ('W') - ensure a writable array +// * 'OWNDATA' ('O') - ensure an array that owns its own data +// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array with specified requirements and type if given. +// +// See Also +// -------- +// asarray : Convert input to an ndarray. +// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// ndarray.flags : Information about the memory layout of the array. +// +// Notes +// ----- +// The returned array will be guaranteed to have the listed requirements +// by making a copy if needed. +// +// Examples +// -------- +// >>> x = np.arange(6).reshape(2,3) +// >>> x.flags +// C_CONTIGUOUS : True +// F_CONTIGUOUS : False +// OWNDATA : False +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False +// +// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) +// >>> y.flags +// C_CONTIGUOUS : False +// F_CONTIGUOUS : True +// OWNDATA : True +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False +// +// +// +//go:linkname Require py.require +func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object +// +// Set how floating-point errors are handled. +// +// Note that operations on integer scalar types (such as `int16`) are +// handled like floating point, and are affected by these settings. +// +// Parameters +// ---------- +// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Set treatment for all types of floating-point errors at once: +// +// - ignore: Take no action when the exception occurs. +// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). +// - raise: Raise a `FloatingPointError`. +// - call: Call a function specified using the `seterrcall` function. +// - print: Print a warning directly to ``stdout``. +// - log: Record error in a Log object specified by `seterrcall`. +// +// The default is not to change the current behavior. +// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for division by zero. +// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point overflow. +// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point underflow. +// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for invalid floating-point operation. +// +// Returns +// ------- +// old_settings : dict +// Dictionary containing the old settings. +// +// See also +// -------- +// seterrcall : Set a callback function for the 'call' mode. +// geterr, geterrcall, errstate +// +// Notes +// ----- +// The floating-point exceptions are defined in the IEEE 754 standard [1]_: +// +// - Division by zero: infinite result obtained from finite numbers. +// - Overflow: result too large to be expressed. +// - Underflow: result so close to zero that some precision +// was lost. +// - Invalid operation: result is not an expressible number, typically +// indicates that a NaN was produced. +// +// .. [1] https://en.wikipedia.org/wiki/IEEE_754 +// +// Examples +// -------- +// >>> old_settings = np.seterr(all='ignore') #seterr to known value +// >>> np.seterr(over='raise') +// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} +// >>> np.seterr(**old_settings) # reset to default +// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} +// +// >>> np.int16(32000) * np.int16(3) +// 30464 +// >>> old_settings = np.seterr(all='warn', over='raise') +// >>> np.int16(32000) * np.int16(3) +// Traceback (most recent call last): +// File "", line 1, in +// FloatingPointError: overflow encountered in scalar multiply +// +// >>> old_settings = np.seterr(all='print') +// >>> np.geterr() +// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} +// >>> np.int16(32000) * np.int16(3) +// 30464 +// +// +// +//go:linkname Seterr py.seterr +func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object +// +// Get the current way of handling floating-point errors. +// +// Returns +// ------- +// res : dict +// A dictionary with keys "divide", "over", "under", and "invalid", +// whose values are from the strings "ignore", "print", "log", "warn", +// "raise", and "call". The keys represent possible floating-point +// exceptions, and the values define how these exceptions are handled. +// +// See Also +// -------- +// geterrcall, seterr, seterrcall +// +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. +// +// Examples +// -------- +// >>> np.geterr() +// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) +// +// >>> oldsettings = np.seterr(all='warn', over='raise') +// >>> np.geterr() +// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) +// +// +// +//go:linkname Geterr py.geterr +func Geterr() *py.Object +// +// Set the size of the buffer used in ufuncs. +// +// Parameters +// ---------- +// size : int +// Size of buffer. +// +// +// +//go:linkname Setbufsize py.setbufsize +func Setbufsize(size *py.Object) *py.Object +// +// Return the size of the buffer used in ufuncs. +// +// Returns +// ------- +// getbufsize : int +// Size of ufunc buffer in bytes. +// +// +// +//go:linkname Getbufsize py.getbufsize +func Getbufsize() *py.Object +// +// Set the floating-point error callback function or log object. +// +// There are two ways to capture floating-point error messages. The first +// is to set the error-handler to 'call', using `seterr`. Then, set +// the function to call using this function. +// +// The second is to set the error-handler to 'log', using `seterr`. +// Floating-point errors then trigger a call to the 'write' method of +// the provided object. +// +// Parameters +// ---------- +// func : callable f(err, flag) or object with write method +// Function to call upon floating-point errors ('call'-mode) or +// object whose 'write' method is used to log such message ('log'-mode). +// +// The call function takes two arguments. The first is a string describing +// the type of error (such as "divide by zero", "overflow", "underflow", +// or "invalid value"), and the second is the status flag. The flag is a +// byte, whose four least-significant bits indicate the type of error, one +// of "divide", "over", "under", "invalid":: +// +// [0 0 0 0 divide over under invalid] +// +// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. +// +// If an object is provided, its write method should take one argument, +// a string. +// +// Returns +// ------- +// h : callable, log instance or None +// The old error handler. +// +// See Also +// -------- +// seterr, geterr, geterrcall +// +// Examples +// -------- +// Callback upon error: +// +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// ... +// +// >>> saved_handler = np.seterrcall(err_handler) +// >>> save_err = np.seterr(all='call') +// +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) +// +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} +// +// Log error message: +// +// >>> class Log: +// ... def write(self, msg): +// ... print("LOG: %s" % msg) +// ... +// +// >>> log = Log() +// >>> saved_handler = np.seterrcall(log) +// >>> save_err = np.seterr(all='log') +// +// >>> np.array([1, 2, 3]) / 0.0 +// LOG: Warning: divide by zero encountered in divide +// array([inf, inf, inf]) +// +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} +// +// +// +//go:linkname Seterrcall py.seterrcall +func Seterrcall(func_ *py.Object) *py.Object +// +// Return the current callback function used on floating-point errors. +// +// When the error handling for a floating-point error (one of "divide", +// "over", "under", or "invalid") is set to 'call' or 'log', the function +// that is called or the log instance that is written to is returned by +// `geterrcall`. This function or log instance has been set with +// `seterrcall`. +// +// Returns +// ------- +// errobj : callable, log instance or None +// The current error handler. If no handler was set through `seterrcall`, +// ``None`` is returned. +// +// See Also +// -------- +// seterrcall, seterr, geterr +// +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. +// +// Examples +// -------- +// >>> np.geterrcall() # we did not yet set a handler, returns None +// +// >>> oldsettings = np.seterr(all='call') +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// >>> oldhandler = np.seterrcall(err_handler) +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) +// +// >>> cur_handler = np.geterrcall() +// >>> cur_handler is err_handler +// True +// +// +// +//go:linkname Geterrcall py.geterrcall +func Geterrcall() *py.Object +// +// Return a description for the given data type code. +// +// Parameters +// ---------- +// char : str +// Data type code. +// +// Returns +// ------- +// out : str +// Description of the input data type code. +// +// See Also +// -------- +// dtype, typecodes +// +// Examples +// -------- +// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', +// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] +// >>> for typechar in typechars: +// ... print(typechar, ' : ', np.typename(typechar)) +// ... +// S1 : character +// ? : bool +// B : unsigned char +// D : complex double precision +// G : complex long double precision +// F : complex single precision +// I : unsigned integer +// H : unsigned short +// L : unsigned long integer +// O : object +// Q : unsigned long long integer +// S : string +// U : unicode +// V : void +// b : signed char +// d : double precision +// g : long precision +// f : single precision +// i : integer +// h : short +// l : long integer +// q : long long integer +// +// +// +//go:linkname Typename py.typename +func Typename(char *py.Object) *py.Object +// +// Return the character for the minimum-size type to which given types can +// be safely cast. +// +// The returned type character must represent the smallest size dtype such +// that an array of the returned type can handle the data from an array of +// all types in `typechars` (or if `typechars` is an array, then its +// dtype.char). +// +// Parameters +// ---------- +// typechars : list of str or array_like +// If a list of strings, each string should represent a dtype. +// If array_like, the character representation of the array dtype is used. +// typeset : str or list of str, optional +// The set of characters that the returned character is chosen from. +// The default set is 'GDFgdf'. +// default : str, optional +// The default character, this is returned if none of the characters in +// `typechars` matches a character in `typeset`. +// +// Returns +// ------- +// typechar : str +// The character representing the minimum-size type that was found. +// +// See Also +// -------- +// dtype, sctype2char, maximum_sctype +// +// Examples +// -------- +// >>> np.mintypecode(['d', 'f', 'S']) +// 'd' +// >>> x = np.array([1.1, 2-3.j]) +// >>> np.mintypecode(x) +// 'D' +// +// >>> np.mintypecode('abceh', default='G') +// 'G' +// +// +// +//go:linkname Mintypecode py.mintypecode +func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *py.Object) *py.Object +// +// Return the indices to access the main diagonal of an array. +// +// This returns a tuple of indices that can be used to access the main +// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape +// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for +// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` +// for ``i = [0..n-1]``. +// +// Parameters +// ---------- +// n : int +// The size, along each dimension, of the arrays for which the returned +// indices can be used. +// +// ndim : int, optional +// The number of dimensions. +// +// See Also +// -------- +// diag_indices_from +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Create a set of indices to access the diagonal of a (4, 4) array: +// +// >>> di = np.diag_indices(4) +// >>> di +// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// >>> a[di] = 100 +// >>> a +// array([[100, 1, 2, 3], +// [ 4, 100, 6, 7], +// [ 8, 9, 100, 11], +// [ 12, 13, 14, 100]]) +// +// Now, we create indices to manipulate a 3-D array: +// +// >>> d3 = np.diag_indices(2, 3) +// >>> d3 +// (array([0, 1]), array([0, 1]), array([0, 1])) +// +// And use it to set the diagonal of an array of zeros to 1: +// +// >>> a = np.zeros((2, 2, 2), dtype=int) +// >>> a[d3] = 1 +// >>> a +// array([[[1, 0], +// [0, 0]], +// [[0, 0], +// [0, 1]]]) +// +// +// +//go:linkname DiagIndices py.diag_indices +func DiagIndices(n *py.Object, ndim *py.Object) *py.Object +// +// Check whether or not an object can be iterated over. +// +// Parameters +// ---------- +// y : object +// Input object. +// +// Returns +// ------- +// b : bool +// Return ``True`` if the object has an iterator method or is a +// sequence and ``False`` otherwise. +// +// +// Examples +// -------- +// >>> np.iterable([1, 2, 3]) +// True +// >>> np.iterable(2) +// False +// +// Notes +// ----- +// In most cases, the results of ``np.iterable(obj)`` are consistent with +// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is +// the treatment of 0-dimensional arrays:: +// +// >>> from collections.abc import Iterable +// >>> a = np.array(1.0) # 0-dimensional numpy array +// >>> isinstance(a, Iterable) +// True +// >>> np.iterable(a) +// False +// +// +// +//go:linkname Iterable py.iterable +func Iterable(y *py.Object) *py.Object +// +// Display a message on a device. +// +// Parameters +// ---------- +// mesg : str +// Message to display. +// device : object +// Device to write message. If None, defaults to ``sys.stdout`` which is +// very similar to ``print``. `device` needs to have ``write()`` and +// ``flush()`` methods. +// linefeed : bool, optional +// Option whether to print a line feed or not. Defaults to True. +// +// Raises +// ------ +// AttributeError +// If `device` does not have a ``write()`` or ``flush()`` method. +// +// Examples +// -------- +// Besides ``sys.stdout``, a file-like object can also be used as it has +// both required methods: +// +// >>> from io import StringIO +// >>> buf = StringIO() +// >>> np.disp(u'"Display" in a file', device=buf) +// >>> buf.getvalue() +// '"Display" in a file\n' +// +// +// +//go:linkname Disp py.disp +func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object +// Convert the input to an array, checking for NaNs or Infs. +// +// Parameters +// ---------- +// a : array_like +// Input data, in any form that can be converted to an array. This +// includes lists, lists of tuples, tuples, tuples of tuples, tuples +// of lists and ndarrays. Success requires no NaNs or Infs. +// dtype : data-type, optional +// By default, the data-type is inferred from the input data. +// order : {'C', 'F', 'A', 'K'}, optional +// Memory layout. 'A' and 'K' depend on the order of input array a. +// 'C' row-major (C-style), +// 'F' column-major (Fortran-style) memory representation. +// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise +// 'K' (keep) preserve input order +// Defaults to 'C'. +// +// Returns +// ------- +// out : ndarray +// Array interpretation of `a`. No copy is performed if the input +// is already an ndarray. If `a` is a subclass of ndarray, a base +// class ndarray is returned. +// +// Raises +// ------ +// ValueError +// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). +// +// See Also +// -------- +// asarray : Create and array. +// asanyarray : Similar function which passes through subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfarray : Convert input to a floating point ndarray. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// fromiter : Create an array from an iterator. +// fromfunction : Construct an array by executing a function on grid +// positions. +// +// Examples +// -------- +// Convert a list into an array. If all elements are finite +// ``asarray_chkfinite`` is identical to ``asarray``. +// +// >>> a = [1, 2] +// >>> np.asarray_chkfinite(a, dtype=float) +// array([1., 2.]) +// +// Raises ValueError if array_like contains Nans or Infs. +// +// >>> a = [1, 2, np.inf] +// >>> try: +// ... np.asarray_chkfinite(a) +// ... except ValueError: +// ... print('ValueError') +// ... +// ValueError +// +// +// +//go:linkname AsarrayChkfinite py.asarray_chkfinite +func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// Return the Hamming window. +// +// The Hamming window is a taper formed by using a weighted cosine. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hanning, kaiser +// +// Notes +// ----- +// The Hamming window is defined as +// +// .. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 +// +// The Hamming was named for R. W. Hamming, an associate of J. W. Tukey +// and is described in Blackman and Tukey. It was recommended for +// smoothing the truncated autocovariance function in the time domain. +// Most references to the Hamming window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 109-110. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// +// Examples +// -------- +// >>> np.hamming(12) +// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary +// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, +// 0.15302337, 0.08 ]) +// +// Plot the window and the frequency response: +// +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hamming(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hamming window") +// Text(0.5, 1.0, 'Hamming window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Hamming window") +// Text(0.5, 1.0, 'Frequency response of Hamming window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() +// +// +// +//go:linkname Hamming py.hamming +func Hamming(M *py.Object) *py.Object +// +// Return the Hanning window. +// +// The Hanning window is a taper formed by using a weighted cosine. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : ndarray, shape(M,) +// The window, with the maximum value normalized to one (the value +// one appears only if `M` is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, kaiser +// +// Notes +// ----- +// The Hanning window is defined as +// +// .. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 +// +// The Hanning was named for Julius von Hann, an Austrian meteorologist. +// It is also known as the Cosine Bell. Some authors prefer that it be +// called a Hann window, to help avoid confusion with the very similar +// Hamming window. +// +// Most references to the Hanning window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 106-108. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// +// Examples +// -------- +// >>> np.hanning(12) +// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, +// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, +// 0.07937323, 0. ]) +// +// Plot the window and its frequency response: +// +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hanning(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hann window") +// Text(0.5, 1.0, 'Hann window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of the Hann window") +// Text(0.5, 1.0, 'Frequency response of the Hann window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() +// +// +// +//go:linkname Hanning py.hanning +func Hanning(M *py.Object) *py.Object +// +// Return the Bartlett window. +// +// The Bartlett window is very similar to a triangular window, except +// that the end points are at zero. It is often used in signal +// processing for tapering a signal, without generating too much +// ripple in the frequency domain. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : array +// The triangular window, with the maximum value normalized to one +// (the value one appears only if the number of samples is odd), with +// the first and last samples equal to zero. +// +// See Also +// -------- +// blackman, hamming, hanning, kaiser +// +// Notes +// ----- +// The Bartlett window is defined as +// +// .. math:: w(n) = \frac{2}{M-1} \left( +// \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| +// \right) +// +// Most references to the Bartlett window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. Note that convolution with this window produces linear +// interpolation. It is also known as an apodization (which means "removing +// the foot", i.e. smoothing discontinuities at the beginning and end of the +// sampled signal) or tapering function. The Fourier transform of the +// Bartlett window is the product of two sinc functions. Note the excellent +// discussion in Kanasewich [2]_. +// +// References +// ---------- +// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", +// Biometrika 37, 1-16, 1950. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 109-110. +// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal +// Processing", Prentice-Hall, 1999, pp. 468-471. +// .. [4] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 429. +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.bartlett(12) +// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary +// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, +// 0.18181818, 0. ]) +// +// Plot the window and its frequency response (requires SciPy and matplotlib): +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.bartlett(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Bartlett window") +// Text(0.5, 1.0, 'Bartlett window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Bartlett window") +// Text(0.5, 1.0, 'Frequency response of Bartlett window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() +// +// +// +//go:linkname Bartlett py.bartlett +func Bartlett(M *py.Object) *py.Object +// +// Return the Blackman window. +// +// The Blackman window is a taper formed by using the first three +// terms of a summation of cosines. It was designed to have close to the +// minimal leakage possible. It is close to optimal, only slightly worse +// than a Kaiser window. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an empty +// array is returned. +// +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value one +// appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, hamming, hanning, kaiser +// +// Notes +// ----- +// The Blackman window is defined as +// +// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) +// +// Most references to the Blackman window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. It is known as a +// "near optimal" tapering function, almost as good (by some measures) +// as the kaiser window. +// +// References +// ---------- +// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, +// Dover Publications, New York. +// +// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. +// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.blackman(12) +// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary +// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, +// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, +// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) +// +// Plot the window and the frequency response: +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.blackman(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Blackman window") +// Text(0.5, 1.0, 'Blackman window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Blackman window") +// Text(0.5, 1.0, 'Frequency response of Blackman window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() +// +// +// +//go:linkname Blackman py.blackman +func Blackman(M *py.Object) *py.Object +// +// Return the Kaiser window. +// +// The Kaiser window is a taper formed by using a Bessel function. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// beta : float +// Shape parameter for window. +// +// Returns +// ------- +// out : array +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, hanning +// +// Notes +// ----- +// The Kaiser window is defined as +// +// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} +// \right)/I_0(\beta) +// +// with +// +// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, +// +// where :math:`I_0` is the modified zeroth-order Bessel function. +// +// The Kaiser was named for Jim Kaiser, who discovered a simple +// approximation to the DPSS window based on Bessel functions. The Kaiser +// window is a very good approximation to the Digital Prolate Spheroidal +// Sequence, or Slepian window, which is the transform which maximizes the +// energy in the main lobe of the window relative to total energy. +// +// The Kaiser can approximate many other windows by varying the beta +// parameter. +// +// ==== ======================= +// beta Window shape +// ==== ======================= +// 0 Rectangular +// 5 Similar to a Hamming +// 6 Similar to a Hanning +// 8.6 Similar to a Blackman +// ==== ======================= +// +// A beta value of 14 is probably a good starting point. Note that as beta +// gets large, the window narrows, and so the number of samples needs to be +// large enough to sample the increasingly narrow spike, otherwise NaNs will +// get returned. +// +// Most references to the Kaiser window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by +// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. +// John Wiley and Sons, New York, (1966). +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 177-178. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.kaiser(12, 14) +// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary +// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, +// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, +// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) +// +// +// Plot the window and the frequency response: +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.kaiser(51, 14) +// >>> plt.plot(window) +// [] +// >>> plt.title("Kaiser window") +// Text(0.5, 1.0, 'Kaiser window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Kaiser window") +// Text(0.5, 1.0, 'Frequency response of Kaiser window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// (-0.5, 0.5, -100.0, ...) # may vary +// >>> plt.show() +// +// +// +//go:linkname Kaiser py.kaiser +func Kaiser(M *py.Object, beta *py.Object) *py.Object +// +// Add documentation to an existing object, typically one defined in C +// +// The purpose is to allow easier editing of the docstrings without requiring +// a re-compile. This exists primarily for internal use within numpy itself. +// +// Parameters +// ---------- +// place : str +// The absolute name of the module to import from +// obj : str +// The name of the object to add documentation to, typically a class or +// function name +// doc : {str, Tuple[str, str], List[Tuple[str, str]]} +// If a string, the documentation to apply to `obj` +// +// If a tuple, then the first element is interpreted as an attribute of +// `obj` and the second as the docstring to apply - ``(method, docstring)`` +// +// If a list, then each element of the list should be a tuple of length +// two - ``[(method1, docstring1), (method2, docstring2), ...]`` +// warn_on_python : bool +// If True, the default, emit `UserWarning` if this is used to attach +// documentation to a pure-python object. +// +// Notes +// ----- +// This routine never raises an error if the docstring can't be written, but +// will raise an error if the object being documented does not exist. +// +// This routine cannot modify read-only docstrings, as appear +// in new-style classes or built-in functions. Because this +// routine never raises an error the caller must check manually +// that the docstrings were changed. +// +// Since this function grabs the ``char *`` from a c-level str object and puts +// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of +// C-API best-practices, by: +// +// - modifying a `PyTypeObject` after calling `PyType_Ready` +// - calling `Py_INCREF` on the str and losing the reference, so the str +// will never be released +// +// If possible it should be avoided. +// +// +//go:linkname AddNewdoc py.add_newdoc +func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object +// Find the wrapper for the array with the highest priority. +// +// In case of ties, leftmost wins. If no wrapper is found, return None +// +// +//go:linkname GetArrayWrap py.get_array_wrap +func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object +// +// Broadcast the input shapes into a single shape. +// +// :ref:`Learn more about broadcasting here `. +// +// .. versionadded:: 1.20.0 +// +// Parameters +// ---------- +// `*args` : tuples of ints, or ints +// The shapes to be broadcast against each other. +// +// Returns +// ------- +// tuple +// Broadcasted shape. +// +// Raises +// ------ +// ValueError +// If the shapes are not compatible and cannot be broadcast according +// to NumPy's broadcasting rules. +// +// See Also +// -------- +// broadcast +// broadcast_arrays +// broadcast_to +// +// Examples +// -------- +// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) +// (3, 2) +// +// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) +// (5, 6, 7) +// +// +//go:linkname BroadcastShapes py.broadcast_shapes +func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object +// +// Return a 2-D array with ones on the diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// Number of rows in the output. +// M : int, optional +// Number of columns in the output. If None, defaults to `N`. +// k : int, optional +// Index of the diagonal: 0 (the default) refers to the main diagonal, +// a positive value refers to an upper diagonal, and a negative value +// to a lower diagonal. +// dtype : data-type, optional +// Data-type of the returned array. +// order : {'C', 'F'}, optional +// Whether the output should be stored in row-major (C-style) or +// column-major (Fortran-style) order in memory. +// +// .. versionadded:: 1.14.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// I : ndarray of shape (N,M) +// An array where all elements are equal to zero, except for the `k`-th +// diagonal, whose values are equal to one. +// +// See Also +// -------- +// identity : (almost) equivalent function +// diag : diagonal 2-D array from a 1-D array specified by the user. +// +// Examples +// -------- +// >>> np.eye(2, dtype=int) +// array([[1, 0], +// [0, 1]]) +// >>> np.eye(3, k=1) +// array([[0., 1., 0.], +// [0., 0., 1.], +// [0., 0., 0.]]) +// +// +// +//go:linkname Eye py.eye +func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// An array with ones at and below the given diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// Number of rows in the array. +// M : int, optional +// Number of columns in the array. +// By default, `M` is taken equal to `N`. +// k : int, optional +// The sub-diagonal at and below which the array is filled. +// `k` = 0 is the main diagonal, while `k` < 0 is below it, +// and `k` > 0 is above. The default is 0. +// dtype : dtype, optional +// Data type of the returned array. The default is float. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// tri : ndarray of shape (N, M) +// Array with its lower triangle filled with ones and zero elsewhere; +// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. +// +// Examples +// -------- +// >>> np.tri(3, 5, 2, dtype=int) +// array([[1, 1, 1, 0, 0], +// [1, 1, 1, 1, 0], +// [1, 1, 1, 1, 1]]) +// +// >>> np.tri(3, 5, -1) +// array([[0., 0., 0., 0., 0.], +// [1., 0., 0., 0., 0.], +// [1., 1., 0., 0., 0.]]) +// +// +// +//go:linkname Tri py.tri +func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object +// +// Return the indices to access (n, n) arrays, given a masking function. +// +// Assume `mask_func` is a function that, for a square array a of size +// ``(n, n)`` with a possible offset argument `k`, when called as +// ``mask_func(a, k)`` returns a new array with zeros in certain locations +// (functions like `triu` or `tril` do precisely this). Then this function +// returns the indices where the non-zero values would be located. +// +// Parameters +// ---------- +// n : int +// The returned indices will be valid to access arrays of shape (n, n). +// mask_func : callable +// A function whose call signature is similar to that of `triu`, `tril`. +// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. +// `k` is an optional argument to the function. +// k : scalar +// An optional argument which is passed through to `mask_func`. Functions +// like `triu`, `tril` take a second argument that is interpreted as an +// offset. +// +// Returns +// ------- +// indices : tuple of arrays. +// The `n` arrays of indices corresponding to the locations where +// ``mask_func(np.ones((n, n)), k)`` is True. +// +// See Also +// -------- +// triu, tril, triu_indices, tril_indices +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// These are the indices that would allow you to access the upper triangular +// part of any 3x3 array: +// +// >>> iu = np.mask_indices(3, np.triu) +// +// For example, if `a` is a 3x3 array: +// +// >>> a = np.arange(9).reshape(3, 3) +// >>> a +// array([[0, 1, 2], +// [3, 4, 5], +// [6, 7, 8]]) +// >>> a[iu] +// array([0, 1, 2, 4, 5, 8]) +// +// An offset can be passed also to the masking function. This gets us the +// indices starting on the first diagonal right of the main one: +// +// >>> iu1 = np.mask_indices(3, np.triu, 1) +// +// with which we now extract only three elements: +// +// >>> a[iu1] +// array([1, 2, 5]) +// +// +// +//go:linkname MaskIndices py.mask_indices +func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object +// +// Return the indices for the lower-triangle of an (n, m) array. +// +// Parameters +// ---------- +// n : int +// The row dimension of the arrays for which the returned +// indices will be valid. +// k : int, optional +// Diagonal offset (see `tril` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// +// +// Returns +// ------- +// inds : tuple of arrays +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. +// +// See also +// -------- +// triu_indices : similar function, for upper-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// tril, triu +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Compute two different sets of indices to access 4x4 arrays, one for the +// lower triangular part starting at the main diagonal, and one starting two +// diagonals further right: +// +// >>> il1 = np.tril_indices(4) +// >>> il2 = np.tril_indices(4, 2) +// +// Here is how they can be used with a sample array: +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Both for indexing: +// +// >>> a[il1] +// array([ 0, 4, 5, ..., 13, 14, 15]) +// +// And for assigning values: +// +// >>> a[il1] = -1 +// >>> a +// array([[-1, 1, 2, 3], +// [-1, -1, 6, 7], +// [-1, -1, -1, 11], +// [-1, -1, -1, -1]]) +// +// These cover almost the whole array (two diagonals right of the main one): +// +// >>> a[il2] = -10 +// >>> a +// array([[-10, -10, -10, 3], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10]]) +// +// +// +//go:linkname TrilIndices py.tril_indices +func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Return the indices for the upper-triangle of an (n, m) array. +// +// Parameters +// ---------- +// n : int +// The size of the arrays for which the returned indices will +// be valid. +// k : int, optional +// Diagonal offset (see `triu` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// +// +// Returns +// ------- +// inds : tuple, shape(2) of ndarrays, shape(`n`) +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. Can be used +// to slice a ndarray of shape(`n`, `n`). +// +// See also +// -------- +// tril_indices : similar function, for lower-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// triu, tril +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Compute two different sets of indices to access 4x4 arrays, one for the +// upper triangular part starting at the main diagonal, and one starting two +// diagonals further right: +// +// >>> iu1 = np.triu_indices(4) +// >>> iu2 = np.triu_indices(4, 2) +// +// Here is how they can be used with a sample array: +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Both for indexing: +// +// >>> a[iu1] +// array([ 0, 1, 2, ..., 10, 11, 15]) +// +// And for assigning values: +// +// >>> a[iu1] = -1 +// >>> a +// array([[-1, -1, -1, -1], +// [ 4, -1, -1, -1], +// [ 8, 9, -1, -1], +// [12, 13, 14, -1]]) +// +// These cover only a small part of the whole array (two diagonals right +// of the main one): +// +// >>> a[iu2] = -10 +// >>> a +// array([[ -1, -1, -10, -10], +// [ 4, -1, -1, -10], +// [ 8, 9, -1, -1], +// [ 12, 13, 14, -1]]) +// +// +// +//go:linkname TriuIndices py.triu_indices +func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Determine if a class is a subclass of a second class. +// +// `issubclass_` is equivalent to the Python built-in ``issubclass``, +// except that it returns False instead of raising a TypeError if one +// of the arguments is not a class. +// +// Parameters +// ---------- +// arg1 : class +// Input class. True is returned if `arg1` is a subclass of `arg2`. +// arg2 : class or tuple of classes. +// Input class. If a tuple of classes, True is returned if `arg1` is a +// subclass of any of the tuple elements. +// +// Returns +// ------- +// out : bool +// Whether `arg1` is a subclass of `arg2` or not. +// +// See Also +// -------- +// issubsctype, issubdtype, issctype +// +// Examples +// -------- +// >>> np.issubclass_(np.int32, int) +// False +// >>> np.issubclass_(np.int32, float) +// False +// >>> np.issubclass_(np.float64, float) +// True +// +// +// +//go:linkname Issubclass py.issubclass_ +func Issubclass(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Determine if the first argument is a subclass of the second argument. +// +// Parameters +// ---------- +// arg1, arg2 : dtype or dtype specifier +// Data-types. +// +// Returns +// ------- +// out : bool +// The result. +// +// See Also +// -------- +// issctype, issubdtype, obj2sctype +// +// Examples +// -------- +// >>> np.issubsctype('S8', str) +// False +// >>> np.issubsctype(np.array([1]), int) +// True +// >>> np.issubsctype(np.array([1]), float) +// False +// +// +// +//go:linkname Issubsctype py.issubsctype +func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Issues a DeprecationWarning, adds warning to `old_name`'s +// docstring, rebinds ``old_name.__name__`` and returns the new +// function object. +// +// This function may also be used as a decorator. +// +// Parameters +// ---------- +// func : function +// The function to be deprecated. +// old_name : str, optional +// The name of the function to be deprecated. Default is None, in +// which case the name of `func` is used. +// new_name : str, optional +// The new name for the function. Default is None, in which case the +// deprecation message is that `old_name` is deprecated. If given, the +// deprecation message is that `old_name` is deprecated and `new_name` +// should be used instead. +// message : str, optional +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. +// +// Returns +// ------- +// old_func : function +// The deprecated function. +// +// Examples +// -------- +// Note that ``olduint`` returns a value after printing Deprecation +// Warning: +// +// >>> olduint = np.deprecate(np.uint) +// DeprecationWarning: `uint64` is deprecated! # may vary +// >>> olduint(6) +// 6 +// +// +// +//go:linkname Deprecate py.deprecate +func Deprecate(__llgo_va_list ...interface{}) *py.Object +// +// Deprecates a function and includes the deprecation in its docstring. +// +// This function is used as a decorator. It returns an object that can be +// used to issue a DeprecationWarning, by passing the to-be decorated +// function as argument, this adds warning to the to-be decorated function's +// docstring and returns the new function object. +// +// See Also +// -------- +// deprecate : Decorate a function such that it issues a `DeprecationWarning` +// +// Parameters +// ---------- +// msg : str +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. +// +// Returns +// ------- +// obj : object +// +// +// +//go:linkname DeprecateWithDoc py.deprecate_with_doc +func DeprecateWithDoc(msg *py.Object) *py.Object +// +// Return the directory that contains the NumPy \*.h header files. +// +// Extension modules that need to compile against NumPy should use this +// function to locate the appropriate include directory. +// +// Notes +// ----- +// When using ``distutils``, for example in ``setup.py``:: +// +// import numpy as np +// ... +// Extension('extension_name', ... +// include_dirs=[np.get_include()]) +// ... +// +// +// +//go:linkname GetInclude py.get_include +func GetInclude() *py.Object +// +// Get help information for an array, function, class, or module. +// +// Parameters +// ---------- +// object : object or str, optional +// Input object or name to get information about. If `object` is +// an `ndarray` instance, information about the array is printed. +// If `object` is a numpy object, its docstring is given. If it is +// a string, available modules are searched for matching objects. +// If None, information about `info` itself is returned. +// maxwidth : int, optional +// Printing width. +// output : file like object, optional +// File like object that the output is written to, default is +// ``None``, in which case ``sys.stdout`` will be used. +// The object has to be opened in 'w' or 'a' mode. +// toplevel : str, optional +// Start search at this level. +// +// See Also +// -------- +// source, lookfor +// +// Notes +// ----- +// When used interactively with an object, ``np.info(obj)`` is equivalent +// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython +// prompt. +// +// Examples +// -------- +// >>> np.info(np.polyval) # doctest: +SKIP +// polyval(p, x) +// Evaluate the polynomial p at x. +// ... +// +// When using a string for `object` it is possible to get multiple results. +// +// >>> np.info('fft') # doctest: +SKIP +// *** Found in numpy *** +// Core FFT routines +// ... +// *** Found in numpy.fft *** +// fft(a, n=None, axis=-1) +// ... +// *** Repeat reference found in numpy.fft.fftpack *** +// *** Total of 3 references found. *** +// +// When the argument is an array, information about the array is printed. +// +// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) +// >>> np.info(a) +// class: ndarray +// shape: (2, 3) +// strides: (24, 8) +// itemsize: 8 +// aligned: True +// contiguous: True +// fortran: False +// data pointer: 0x562b6e0d2860 # may vary +// byteorder: little +// byteswap: False +// type: complex64 +// +// +// +//go:linkname Info py.info +func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object +// +// Print or write to a file the source code for a NumPy object. +// +// The source code is only returned for objects written in Python. Many +// functions and classes are defined in C and will therefore not return +// useful information. +// +// Parameters +// ---------- +// object : numpy object +// Input object. This can be any object (function, class, module, +// ...). +// output : file object, optional +// If `output` not supplied then source code is printed to screen +// (sys.stdout). File object must be created with either write 'w' or +// append 'a' modes. +// +// See Also +// -------- +// lookfor, info +// +// Examples +// -------- +// >>> np.source(np.interp) #doctest: +SKIP +// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py +// def interp(x, xp, fp, left=None, right=None): +// """.... (full docstring printed)""" +// if isinstance(x, (float, int, number)): +// return compiled_interp([x], xp, fp, left, right).item() +// else: +// return compiled_interp(x, xp, fp, left, right) +// +// The source code is only returned for objects written in Python. +// +// >>> np.source(np.array) #doctest: +SKIP +// Not available for this object. +// +// +// +//go:linkname Source py.source +func Source(object *py.Object, output *py.Object) *py.Object +// +// Print the NumPy arrays in the given dictionary. +// +// If there is no dictionary passed in or `vardict` is None then returns +// NumPy arrays in the globals() dictionary (all NumPy arrays in the +// namespace). +// +// Parameters +// ---------- +// vardict : dict, optional +// A dictionary possibly containing ndarrays. Default is globals(). +// +// Returns +// ------- +// out : None +// Returns 'None'. +// +// Notes +// ----- +// Prints out the name, shape, bytes and type of all of the ndarrays +// present in `vardict`. +// +// Examples +// -------- +// >>> a = np.arange(10) +// >>> b = np.ones(20) +// >>> np.who() +// Name Shape Bytes Type +// =========================================================== +// a 10 80 int64 +// b 20 160 float64 +// Upper bound on total bytes = 240 +// +// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', +// ... 'idx':5} +// >>> np.who(d) +// Name Shape Bytes Type +// =========================================================== +// x 2 16 float64 +// y 3 24 float64 +// Upper bound on total bytes = 40 +// +// +// +//go:linkname Who py.who +func Who(vardict *py.Object) *py.Object +// +// Do a keyword search on docstrings. +// +// A list of objects that matched the search is displayed, +// sorted by relevance. All given keywords need to be found in the +// docstring for it to be returned as a result, but the order does +// not matter. +// +// Parameters +// ---------- +// what : str +// String containing words to look for. +// module : str or list, optional +// Name of module(s) whose docstrings to go through. +// import_modules : bool, optional +// Whether to import sub-modules in packages. Default is True. +// regenerate : bool, optional +// Whether to re-generate the docstring cache. Default is False. +// output : file-like, optional +// File-like object to write the output to. If omitted, use a pager. +// +// See Also +// -------- +// source, info +// +// Notes +// ----- +// Relevance is determined only roughly, by checking if the keywords occur +// in the function name, at the start of a docstring, etc. +// +// Examples +// -------- +// >>> np.lookfor('binary representation') # doctest: +SKIP +// Search results for 'binary representation' +// ------------------------------------------ +// numpy.binary_repr +// Return the binary representation of the input number as a string. +// numpy.core.setup_common.long_double_representation +// Given a binary dump as given by GNU od -b, look for long double +// numpy.base_repr +// Return a string representation of a number in the given base system. +// ... +// +// +// +//go:linkname Lookfor py.lookfor +func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object +// +// Returns pointers to the end-points of an array. +// +// Parameters +// ---------- +// a : ndarray +// Input array. It must conform to the Python-side of the array +// interface. +// +// Returns +// ------- +// (low, high) : tuple of 2 integers +// The first integer is the first byte of the array, the second +// integer is just past the last byte of the array. If `a` is not +// contiguous it will not use every byte between the (`low`, `high`) +// values. +// +// Examples +// -------- +// >>> I = np.eye(2, dtype='f'); I.dtype +// dtype('float32') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// >>> I = np.eye(2); I.dtype +// dtype('float64') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// +// +// +//go:linkname ByteBounds py.byte_bounds +func ByteBounds(a *py.Object) *py.Object +// +// Protected string evaluation. +// +// Evaluate a string containing a Python literal expression without +// allowing the execution of arbitrary non-literal code. +// +// .. warning:: +// +// This function is identical to :py:meth:`ast.literal_eval` and +// has the same security implications. It may not always be safe +// to evaluate large input strings. +// +// Parameters +// ---------- +// source : str +// The string to evaluate. +// +// Returns +// ------- +// obj : object +// The result of evaluating `source`. +// +// Raises +// ------ +// SyntaxError +// If the code has invalid Python syntax, or if it contains +// non-literal code. +// +// Examples +// -------- +// >>> np.safe_eval('1') +// 1 +// >>> np.safe_eval('[1, 2, 3]') +// [1, 2, 3] +// >>> np.safe_eval('{"foo": ("bar", 10.0)}') +// {'foo': ('bar', 10.0)} +// +// >>> np.safe_eval('import os') +// Traceback (most recent call last): +// ... +// SyntaxError: invalid syntax +// +// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') +// Traceback (most recent call last): +// ... +// ValueError: malformed node or string: <_ast.Call object at 0x...> +// +// +// +//go:linkname SafeEval py.safe_eval +func SafeEval(source *py.Object) *py.Object +// +// Print information about various resources in the system +// including available intrinsic support and BLAS/LAPACK library +// in use +// +// .. versionadded:: 1.24.0 +// +// See Also +// -------- +// show_config : Show libraries in the system on which NumPy was built. +// +// Notes +// ----- +// 1. Information is derived with the help of `threadpoolctl `_ +// library if available. +// 2. SIMD related information is derived from ``__cpu_features__``, +// ``__cpu_baseline__`` and ``__cpu_dispatch__`` +// +// +// +//go:linkname ShowRuntime py.show_runtime +func ShowRuntime() *py.Object +// +// Load data from a text file. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : data-type, optional +// Data-type of the resulting array; default: float. If this is a +// structured data-type, the resulting array will be 1-dimensional, and +// each row will be interpreted as an element of the array. In this +// case, the number of columns used must match the number of fields in +// the data-type. +// comments : str or sequence of str or None, optional +// The characters or list of characters used to indicate the start of a +// comment. None implies no comments. For backwards compatibility, byte +// strings will be decoded as 'latin1'. The default is '#'. +// delimiter : str, optional +// The character used to separate the values. For backwards compatibility, +// byte strings will be decoded as 'latin1'. The default is whitespace. +// +// .. versionchanged:: 1.23.0 +// Only single character delimiters are supported. Newline characters +// cannot be used as the delimiter. +// +// converters : dict or callable, optional +// Converter functions to customize value parsing. If `converters` is +// callable, the function is applied to all columns, else it must be a +// dict that maps column number to a parser function. +// See examples for further details. +// Default: None. +// +// .. versionchanged:: 1.23.0 +// The ability to pass a single callable to be applied to all columns +// was added. +// +// skiprows : int, optional +// Skip the first `skiprows` lines, including comments; default: 0. +// usecols : int or sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. +// The default, None, results in all columns being read. +// +// .. versionchanged:: 1.11.0 +// When a single column has to be read it is possible to use +// an integer instead of a tuple. E.g ``usecols = 3`` reads the +// fourth column the same way as ``usecols = (3,)`` would. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = loadtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// ndmin : int, optional +// The returned array will have at least `ndmin` dimensions. +// Otherwise mono-dimensional axes will be squeezed. +// Legal values: 0 (default), 1 or 2. +// +// .. versionadded:: 1.6.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply to input streams. +// The special value 'bytes' enables backward compatibility workarounds +// that ensures you receive byte arrays as results if possible and passes +// 'latin1' encoded strings to converters. Override this value to receive +// unicode arrays and pass strings as input to converters. If set to None +// the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// max_rows : int, optional +// Read `max_rows` rows of content after `skiprows` lines. The default is +// to read all the rows. Note that empty rows containing no data such as +// empty lines and comment lines are not counted towards `max_rows`, +// while such lines are counted in `skiprows`. +// +// .. versionadded:: 1.16.0 +// +// .. versionchanged:: 1.23.0 +// Lines containing no data, including comment lines (e.g., lines +// starting with '#' or as specified via `comments`) are not counted +// towards `max_rows`. +// quotechar : unicode character or None, optional +// The character used to denote the start and end of a quoted item. +// Occurrences of the delimiter or comment characters are ignored within +// a quoted item. The default value is ``quotechar=None``, which means +// quoting support is disabled. +// +// If two consecutive instances of `quotechar` are found within a quoted +// field, the first is treated as an escape character. See examples. +// +// .. versionadded:: 1.23.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Data read from the text file. +// +// See Also +// -------- +// load, fromstring, fromregex +// genfromtxt : Load data with missing values handled as specified. +// scipy.io.loadmat : reads MATLAB data files +// +// Notes +// ----- +// This function aims to be a fast reader for simply formatted files. The +// `genfromtxt` function provides more sophisticated handling of, e.g., +// lines with missing values. +// +// Each row in the input text file must have the same number of values to be +// able to read all values. If all rows do not have same number of values, a +// subset of up to n columns (where n is the least number of values present +// in all rows) can be read by specifying the columns via `usecols`. +// +// .. versionadded:: 1.10.0 +// +// The strings produced by the Python float.hex method can be used as +// input for floats. +// +// Examples +// -------- +// >>> from io import StringIO # StringIO behaves like a file object +// >>> c = StringIO("0 1\n2 3") +// >>> np.loadtxt(c) +// array([[0., 1.], +// [2., 3.]]) +// +// >>> d = StringIO("M 21 72\nF 35 58") +// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), +// ... 'formats': ('S1', 'i4', 'f4')}) +// array([(b'M', 21, 72.), (b'F', 35, 58.)], +// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") +// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) +// >>> x +// array([1., 3.]) +// >>> y +// array([2., 4.]) +// +// The `converters` argument is used to specify functions to preprocess the +// text prior to parsing. `converters` can be a dictionary that maps +// preprocessing functions to each column: +// +// >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n") +// >>> conv = { +// ... 0: lambda x: np.floor(float(x)), # conversion fn for column 0 +// ... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1 +// ... } +// >>> np.loadtxt(s, delimiter=",", converters=conv) +// array([[1., 3.], +// [3., 5.]]) +// +// `converters` can be a callable instead of a dictionary, in which case it +// is applied to all columns: +// +// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") +// >>> import functools +// >>> conv = functools.partial(int, base=16) +// >>> np.loadtxt(s, converters=conv) +// array([[222., 173.], +// [192., 222.]]) +// +// This example shows how `converters` can be used to convert a field +// with a trailing minus sign into a negative number. +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> def conv(fld): +// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) +// ... +// >>> np.loadtxt(s, converters=conv) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Using a callable as the converter can be particularly useful for handling +// values with different formatting, e.g. floats with underscores: +// +// >>> s = StringIO("1 2.7 100_000") +// >>> np.loadtxt(s, converters=float) +// array([1.e+00, 2.7e+00, 1.e+05]) +// +// This idea can be extended to automatically handle values specified in +// many different formats: +// +// >>> def conv(val): +// ... try: +// ... return float(val) +// ... except ValueError: +// ... return float.fromhex(val) +// >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2") +// >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None) +// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) +// +// Note that with the default ``encoding="bytes"``, the inputs to the +// converter function are latin-1 encoded byte strings. To deactivate the +// implicit encoding prior to conversion, use ``encoding=None`` +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x) +// >>> np.loadtxt(s, converters=conv, encoding=None) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Support for quoted fields is enabled with the `quotechar` parameter. +// Comment and delimiter characters are ignored when they appear within a +// quoted item delineated by `quotechar`: +// +// >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// dtype=[('label', '>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"') +// >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"') +// array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20") +// >>> np.loadtxt(d, usecols=(0, 1)) +// array([[ 1., 2.], +// [ 2., 4.], +// [ 3., 9.], +// [ 4., 16.]]) +// +// +// +//go:linkname Loadtxt py.loadtxt +func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object +// +// Load data from a text file, with missing values handled as specified. +// +// Each line past the first `skip_header` lines is split at the `delimiter` +// character, and characters following the `comments` character are discarded. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : dtype, optional +// Data type of the resulting array. +// If None, the dtypes will be determined by the contents of each +// column, individually. +// comments : str, optional +// The character used to indicate the start of a comment. +// All the characters occurring on a line after a comment are discarded. +// delimiter : str, int, or sequence, optional +// The string used to separate values. By default, any consecutive +// whitespaces act as delimiter. An integer or sequence of integers +// can also be provided as width(s) of each field. +// skiprows : int, optional +// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. +// skip_header : int, optional +// The number of lines to skip at the beginning of the file. +// skip_footer : int, optional +// The number of lines to skip at the end of the file. +// converters : variable, optional +// The set of functions that convert the data of a column to a value. +// The converters can also be used to provide a default value +// for missing data: ``converters = {3: lambda s: float(s or 0)}``. +// missing : variable, optional +// `missing` was removed in numpy 1.10. Please use `missing_values` +// instead. +// missing_values : variable, optional +// The set of strings corresponding to missing data. +// filling_values : variable, optional +// The set of values to be used as default when the data are missing. +// usecols : sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. +// names : {None, True, str, sequence}, optional +// If `names` is True, the field names are read from the first line after +// the first `skip_header` lines. This line can optionally be preceded +// by a comment delimiter. If `names` is a sequence or a single-string of +// comma-separated names, the names will be used to define the field names +// in a structured dtype. If `names` is None, the names of the dtype +// fields will be used, if any. +// excludelist : sequence, optional +// A list of names to exclude. This list is appended to the default list +// ['return','file','print']. Excluded names are appended with an +// underscore: for example, `file` would become `file_`. +// deletechars : str, optional +// A string combining invalid characters that must be deleted from the +// names. +// defaultfmt : str, optional +// A format used to define default field names, such as "f%i" or "f_%02i". +// autostrip : bool, optional +// Whether to automatically strip white spaces from the variables. +// replace_space : char, optional +// Character(s) used in replacement of white spaces in the variable +// names. By default, use a '_'. +// case_sensitive : {True, False, 'upper', 'lower'}, optional +// If True, field names are case sensitive. +// If False or 'upper', field names are converted to upper case. +// If 'lower', field names are converted to lower case. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = genfromtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// usemask : bool, optional +// If True, return a masked array. +// If False, return a regular array. +// loose : bool, optional +// If True, do not raise errors for invalid values. +// invalid_raise : bool, optional +// If True, an exception is raised if an inconsistency is detected in the +// number of columns. +// If False, a warning is emitted and the offending lines are skipped. +// max_rows : int, optional +// The maximum number of rows to read. Must not be used with skip_footer +// at the same time. If given, the value must be at least 1. Default is +// to read the entire file. +// +// .. versionadded:: 1.10.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply when `fname` is +// a file object. The special value 'bytes' enables backward compatibility +// workarounds that ensure that you receive byte arrays when possible +// and passes latin1 encoded strings to converters. Override this value to +// receive unicode arrays and pass strings as input to converters. If set +// to None the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// ndmin : int, optional +// Same parameter as `loadtxt` +// +// .. versionadded:: 1.23.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Data read from the text file. If `usemask` is True, this is a +// masked array. +// +// See Also +// -------- +// numpy.loadtxt : equivalent function when no data is missing. +// +// Notes +// ----- +// * When spaces are used as delimiters, or when no delimiter has been given +// as input, there should not be any missing data between two fields. +// * When the variables are named (either by a flexible dtype or with `names`), +// there must not be any header in the file (else a ValueError +// exception is raised). +// * Individual values are not stripped of spaces by default. +// When using a custom converter, make sure the function does remove spaces. +// +// References +// ---------- +// .. [1] NumPy User Guide, section `I/O with NumPy +// `_. +// +// Examples +// -------- +// >>> from io import StringIO +// >>> import numpy as np +// +// Comma delimited file with mixed dtype +// +// >>> s = StringIO(u"1,1.3,abcde") +// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), +// ... ('mystring','S5')], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only +// >>> data = np.genfromtxt(s, dtype=None, +// ... names = ['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) +// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", +// ... names=['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> s = StringIO(u"11.3abcde") +// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], +// ... delimiter=[1,3,5]) +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('intvar', '>> f = StringIO(''' +// ... text,# of chars +// ... hello world,11 +// ... numpy,5''') +// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') +// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], +// dtype=[('f0', 'S12'), ('f1', 'S12')]) +// +// +// +//go:linkname Genfromtxt py.genfromtxt +func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object +// +// Load ASCII data from a file and return it in a record array. +// +// If ``usemask=False`` a standard `recarray` is returned, +// if ``usemask=True`` a MaskedRecords array is returned. +// +// Parameters +// ---------- +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromtxt py.recfromtxt +func Recfromtxt(fname *py.Object) *py.Object +// +// Load ASCII data stored in a comma-separated file. +// +// The returned array is a record array (if ``usemask=False``, see +// `recarray`) or a masked record array (if ``usemask=True``, +// see `ma.mrecords.MaskedRecords`). +// +// Parameters +// ---------- +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function to load ASCII data. +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromcsv py.recfromcsv +func Recfromcsv(fname *py.Object) *py.Object +// +// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. +// +// .. warning:: Loading files that contain object arrays uses the ``pickle`` +// module, which is not secure against erroneous or maliciously +// constructed data. Consider passing ``allow_pickle=False`` to +// load data that is known not to contain object arrays for the +// safer handling of untrusted sources. +// +// Parameters +// ---------- +// file : file-like object, string, or pathlib.Path +// The file to read. File-like objects must support the +// ``seek()`` and ``read()`` methods and must always +// be opened in binary mode. Pickled files require that the +// file-like object support the ``readline()`` method as well. +// mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional +// If not None, then memory-map the file, using the given mode (see +// `numpy.memmap` for a detailed description of the modes). A +// memory-mapped array is kept on disk. However, it can be accessed +// and sliced like any ndarray. Memory mapping is especially useful +// for accessing small fragments of large files without reading the +// entire file into memory. +// allow_pickle : bool, optional +// Allow loading pickled object arrays stored in npy files. Reasons for +// disallowing pickles include security, as loading pickled data can +// execute arbitrary code. If pickles are disallowed, loading object +// arrays will fail. Default: False +// +// .. versionchanged:: 1.16.3 +// Made default False in response to CVE-2019-6446. +// +// fix_imports : bool, optional +// Only useful when loading Python 2 generated pickled files on Python 3, +// which includes npy/npz files containing object arrays. If `fix_imports` +// is True, pickle will try to map the old Python 2 names to the new names +// used in Python 3. +// encoding : str, optional +// What encoding to use when reading Python 2 strings. Only useful when +// loading Python 2 generated pickled files in Python 3, which includes +// npy/npz files containing object arrays. Values other than 'latin1', +// 'ASCII', and 'bytes' are not allowed, as they can corrupt numerical +// data. Default: 'ASCII' +// max_header_size : int, optional +// Maximum allowed size of the header. Large headers may not be safe +// to load securely and thus require explicitly passing a larger value. +// See :py:func:`ast.literal_eval()` for details. +// This option is ignored when `allow_pickle` is passed. In that case +// the file is by definition trusted and the limit is unnecessary. +// +// Returns +// ------- +// result : array, tuple, dict, etc. +// Data stored in the file. For ``.npz`` files, the returned instance +// of NpzFile class must be closed to avoid leaking file descriptors. +// +// Raises +// ------ +// OSError +// If the input file does not exist or cannot be read. +// UnpicklingError +// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. +// ValueError +// The file contains an object array, but ``allow_pickle=False`` given. +// EOFError +// When calling ``np.load`` multiple times on the same file handle, +// if all data has already been read +// +// See Also +// -------- +// save, savez, savez_compressed, loadtxt +// memmap : Create a memory-map to an array stored in a file on disk. +// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. +// +// Notes +// ----- +// - If the file contains pickle data, then whatever object is stored +// in the pickle is returned. +// - If the file is a ``.npy`` file, then a single array is returned. +// - If the file is a ``.npz`` file, then a dictionary-like object is +// returned, containing ``{filename: array}`` key-value pairs, one for +// each file in the archive. +// - If the file is a ``.npz`` file, the returned value supports the +// context manager protocol in a similar fashion to the open function:: +// +// with load('foo.npz') as data: +// a = data['a'] +// +// The underlying file descriptor is closed when exiting the 'with' +// block. +// +// Examples +// -------- +// Store data to disk, and load it again: +// +// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) +// >>> np.load('/tmp/123.npy') +// array([[1, 2, 3], +// [4, 5, 6]]) +// +// Store compressed data to disk, and load it again: +// +// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) +// >>> b=np.array([1, 2]) +// >>> np.savez('/tmp/123.npz', a=a, b=b) +// >>> data = np.load('/tmp/123.npz') +// >>> data['a'] +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> data['b'] +// array([1, 2]) +// >>> data.close() +// +// Mem-map the stored array, and then access the second row +// directly from disk: +// +// >>> X = np.load('/tmp/123.npy', mmap_mode='r') +// >>> X[1, :] +// memmap([4, 5, 6]) +// +// +// +//go:linkname Load py.load +func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object +// +// Construct an array from a text file, using regular expression parsing. +// +// The returned array is always a structured array, and is constructed from +// all matches of the regular expression in the file. Groups in the regular +// expression are converted to fields of the structured array. +// +// Parameters +// ---------- +// file : path or file +// Filename or file object to read. +// +// .. versionchanged:: 1.22.0 +// Now accepts `os.PathLike` implementations. +// regexp : str or regexp +// Regular expression used to parse the file. +// Groups in the regular expression correspond to fields in the dtype. +// dtype : dtype or list of dtypes +// Dtype for the structured array; must be a structured datatype. +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply to input streams. +// +// .. versionadded:: 1.14.0 +// +// Returns +// ------- +// output : ndarray +// The output array, containing the part of the content of `file` that +// was matched by `regexp`. `output` is always a structured array. +// +// Raises +// ------ +// TypeError +// When `dtype` is not a valid dtype for a structured array. +// +// See Also +// -------- +// fromstring, loadtxt +// +// Notes +// ----- +// Dtypes for structured arrays can be specified in several forms, but all +// forms specify at least the data type and field name. For details see +// `basics.rec`. +// +// Examples +// -------- +// >>> from io import StringIO +// >>> text = StringIO("1312 foo\n1534 bar\n444 qux") +// +// >>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything] +// >>> output = np.fromregex(text, regexp, +// ... [('num', np.int64), ('key', 'S3')]) +// >>> output +// array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')], +// dtype=[('num', '>> output['num'] +// array([1312, 1534, 444]) +// +// +// +//go:linkname Fromregex py.fromregex +func Fromregex(file *py.Object, regexp *py.Object, dtype *py.Object, encoding *py.Object) *py.Object +// +// Build a matrix object from a string, nested sequence, or array. +// +// Parameters +// ---------- +// obj : str or array_like +// Input data. If a string, variables in the current scope may be +// referenced by name. +// ldict : dict, optional +// A dictionary that replaces local operands in current frame. +// Ignored if `obj` is not a string or `gdict` is None. +// gdict : dict, optional +// A dictionary that replaces global operands in current frame. +// Ignored if `obj` is not a string. +// +// Returns +// ------- +// out : matrix +// Returns a matrix object, which is a specialized 2-D array. +// +// See Also +// -------- +// block : +// A generalization of this function for N-d arrays, that returns normal +// ndarrays. +// +// Examples +// -------- +// >>> A = np.mat('1 1; 1 1') +// >>> B = np.mat('2 2; 2 2') +// >>> C = np.mat('3 4; 5 6') +// >>> D = np.mat('7 8; 9 0') +// +// All the following expressions construct the same block matrix: +// +// >>> np.bmat([[A, B], [C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat('A,B; C,D') +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// +// +// +//go:linkname Bmat py.bmat +func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. +// +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Mat py.mat +func Mat(data *py.Object, dtype *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. +// +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Asmatrix py.asmatrix +func Asmatrix(data *py.Object, dtype *py.Object) *py.Object +// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the absolute value element-wise. +// +// ``np.abs`` is a shorthand for this function. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// absolute : ndarray +// An ndarray containing the absolute value of +// each element in `x`. For complex input, ``a + ib``, the +// absolute value is :math:`\sqrt{ a^2 + b^2 }`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> x = np.array([-1.2, 1.2]) +// >>> np.absolute(x) +// array([ 1.2, 1.2]) +// >>> np.absolute(1.2 + 1j) +// 1.5620499351813308 +// +// Plot the function over ``[-10, 10]``: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(start=-10, stop=10, num=101) +// >>> plt.plot(x, np.absolute(x)) +// >>> plt.show() +// +// Plot the function over the complex plane: +// +// >>> xx = x + 1j * x[:, np.newaxis] +// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') +// >>> plt.show() +// +// The `abs` function can be used as a shorthand for ``np.absolute`` on +// ndarrays. +// +// >>> x = np.array([-1.2, 1.2]) +// >>> abs(x) +// array([1.2, 1.2]) +// +//go:linkname Abs py.abs +func Abs(__llgo_va_list ...interface{}) *py.Object diff --git a/numpy/numpy_autogen_link.go b/numpy/numpy_autogen_link.go new file mode 100644 index 00000000..bb5882ce --- /dev/null +++ b/numpy/numpy_autogen_link.go @@ -0,0 +1,5 @@ +package numpy + +import _ "github.com/goplus/lib/py" + +// LLGoPackage is defined in the main binding file From 3ce6ab33ad43d8e0a0eae9f982a8da9d63669d80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Fri, 15 Aug 2025 10:16:14 +0800 Subject: [PATCH 12/13] de --- numpy/_demo/main.go | 9 - numpy/go.mod | 5 - numpy/go.sum | 2 - numpy/llpkg.cfg | 16 - numpy/llpyg.cfg | 155 - numpy/numpy.go | 9572 ----------------------------------- numpy/numpy_autogen_link.go | 5 - 7 files changed, 9764 deletions(-) delete mode 100644 numpy/_demo/main.go delete mode 100644 numpy/go.mod delete mode 100644 numpy/go.sum delete mode 100644 numpy/llpkg.cfg delete mode 100644 numpy/llpyg.cfg delete mode 100644 numpy/numpy.go delete mode 100644 numpy/numpy_autogen_link.go diff --git a/numpy/_demo/main.go b/numpy/_demo/main.go deleted file mode 100644 index 15eded01..00000000 --- a/numpy/_demo/main.go +++ /dev/null @@ -1,9 +0,0 @@ -package main - -import ( - "fmt" -) - -func main() { - fmt.Println("Hello, World!") -} \ No newline at end of file diff --git a/numpy/go.mod b/numpy/go.mod deleted file mode 100644 index 82bc5445..00000000 --- a/numpy/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/goplus/llpkg/numpy - -go 1.23 - -require github.com/goplus/lib v0.2.0 diff --git a/numpy/go.sum b/numpy/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/numpy/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy/llpkg.cfg b/numpy/llpkg.cfg deleted file mode 100644 index 44e6cd3e..00000000 --- a/numpy/llpkg.cfg +++ /dev/null @@ -1,16 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "python_version": "3.12", - "index_url": "https://pypi.org/simple/" - } - }, - "package": { - "name": "numpy", - "version": "1.26.4" - } - } -} \ No newline at end of file diff --git a/numpy/llpyg.cfg b/numpy/llpyg.cfg deleted file mode 100644 index b8888a8d..00000000 --- a/numpy/llpyg.cfg +++ /dev/null @@ -1,155 +0,0 @@ -{ - "name": "numpy", - "module": "numpy", - "python": true, - "symMap": { - "abs": "Abs", - "absolute": "Absolute", - "add": "Add", - "all": "All", - "any": "Any", - "arange": "Arange", - "arccos": "Arccos", - "arccosh": "Arccosh", - "arcsin": "Arcsin", - "arcsinh": "Arcsinh", - "arctan": "Arctan", - "arctanh": "Arctanh", - "array": "Array", - "average": "Average", - "bin": "Bin", - "bool": "Bool", - "c_": "C", - "ceil": "Ceil", - "chr": "Chr", - "corrcoef": "Corrcoef", - "cos": "Cos", - "cosh": "Cosh", - "cov": "Cov", - "cross": "Cross", - "diag": "Diag", - "dict": "Dict", - "dir": "Dir", - "divide": "Divide", - "dot": "Dot", - "einsum": "Einsum", - "empty": "Empty", - "enumerate": "Enumerate", - "exp": "Exp", - "eye": "Eye", - "fabs": "Fabs", - "fft": "Fft", - "filter": "Filter", - "float": "Float", - "floor": "Floor", - "format": "Format", - "frozenset": "FrozenSet", - "getattr": "GetAttr", - "hasattr": "HasAttr", - "hash": "Hash", - "help": "Help", - "hex": "Hex", - "id": "ID", - "identity": "Identity", - "inner": "Inner", - "input": "Input", - "int": "Int", - "isinstance": "IsInstance", - "issubclass": "IsSubclass", - "iter": "Iter", - "len": "Len", - "linalg": "Linalg", - "linspace": "Linspace", - "list": "List", - "locals": "Locals", - "log": "Log", - "log10": "Log10", - "log2": "Log2", - "logspace": "Logspace", - "map": "Map", - "matmul": "Matmul", - "max": "Max", - "mean": "Mean", - "median": "Median", - "meshgrid": "Meshgrid", - "mgrid": "Mgrid", - "min": "Min", - "mod": "Mod", - "multiply": "Multiply", - "next": "Next", - "oct": "Oct", - "ogrid": "Ogrid", - "ones": "Ones", - "open": "Open", - "ord": "Ord", - "outer": "Outer", - "percentile": "Percentile", - "pow": "Pow", - "power": "Power", - "print": "Print", - "prod": "Prod", - "ptp": "Ptp", - "quantile": "Quantile", - "r_": "R", - "random": "Random", - "range": "Range", - "remainder": "Remainder", - "repr": "Repr", - "reversed": "Reversed", - "rint": "Rint", - "round": "Round", - "set": "Set", - "setattr": "SetAttr", - "sign": "Sign", - "sin": "Sin", - "sinh": "Sinh", - "sorted": "Sorted", - "sqrt": "Sqrt", - "std": "Std", - "str": "Str", - "subtract": "Subtract", - "sum": "Sum", - "tan": "Tan", - "tanh": "Tanh", - "tensordot": "Tensordot", - "tri": "Tri", - "tril": "Tril", - "triu": "Triu", - "trunc": "Trunc", - "tuple": "Tuple", - "type": "Type", - "vander": "Vander", - "var": "Var", - "vars": "Vars", - "zeros": "Zeros", - "zip": "Zip" - }, - "deps": [ - "py" - ], - "include": [ - "numpy" - ], - "exclude": [ - "__builtins__", - "__cached__", - "__doc__", - "__file__", - "__loader__", - "__name__", - "__package__", - "__spec__" - ], - "constants": { - "bool_": "Bool", - "e": "E", - "float32": "Float32", - "float64": "Float64", - "inf": "Inf", - "int32": "Int32", - "int64": "Int64", - "nan": "NaN", - "pi": "Pi", - "uint8": "Uint8" - } -} \ No newline at end of file diff --git a/numpy/numpy.go b/numpy/numpy.go deleted file mode 100644 index 7cfce191..00000000 --- a/numpy/numpy.go +++ /dev/null @@ -1,9572 +0,0 @@ -package numpy - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -const LLGoPackage = "py.numpy" -// -// Show libraries and system information on which NumPy was built -// and is being used -// -// Parameters -// ---------- -// mode : {`'stdout'`, `'dicts'`}, optional. -// Indicates how to display the config information. -// `'stdout'` prints to console, `'dicts'` returns a dictionary -// of the configuration. -// -// Returns -// ------- -// out : {`dict`, `None`} -// If mode is `'dicts'`, a dict is returned, else None -// -// See Also -// -------- -// get_include : Returns the directory containing NumPy C -// header files. -// -// Notes -// ----- -// 1. The `'stdout'` mode will give more readable -// output if ``pyyaml`` is installed -// -// -// -//go:linkname ShowConfig py.show_config -func ShowConfig(mode *py.Object) *py.Object -// -// Return an array representing the indices of a grid. -// -// Compute an array where the subarrays contain index values 0, 1, ... -// varying only along the corresponding axis. -// -// Parameters -// ---------- -// dimensions : sequence of ints -// The shape of the grid. -// dtype : dtype, optional -// Data type of the result. -// sparse : boolean, optional -// Return a sparse representation of the grid instead of a dense -// representation. Default is False. -// -// .. versionadded:: 1.17 -// -// Returns -// ------- -// grid : one ndarray or tuple of ndarrays -// If sparse is False: -// Returns one array of grid indices, -// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. -// If sparse is True: -// Returns a tuple of arrays, with -// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with -// dimensions[i] in the ith place -// -// See Also -// -------- -// mgrid, ogrid, meshgrid -// -// Notes -// ----- -// The output shape in the dense case is obtained by prepending the number -// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` -// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is -// ``(N, r0, ..., rN-1)``. -// -// The subarrays ``grid[k]`` contains the N-D array of indices along the -// ``k-th`` axis. Explicitly:: -// -// grid[k, i0, i1, ..., iN-1] = ik -// -// Examples -// -------- -// >>> grid = np.indices((2, 3)) -// >>> grid.shape -// (2, 2, 3) -// >>> grid[0] # row indices -// array([[0, 0, 0], -// [1, 1, 1]]) -// >>> grid[1] # column indices -// array([[0, 1, 2], -// [0, 1, 2]]) -// -// The indices can be used as an index into an array. -// -// >>> x = np.arange(20).reshape(5, 4) -// >>> row, col = np.indices((2, 3)) -// >>> x[row, col] -// array([[0, 1, 2], -// [4, 5, 6]]) -// -// Note that it would be more straightforward in the above example to -// extract the required elements directly with ``x[:2, :3]``. -// -// If sparse is set to true, the grid will be returned in a sparse -// representation. -// -// >>> i, j = np.indices((2, 3), sparse=True) -// >>> i.shape -// (2, 1) -// >>> j.shape -// (1, 3) -// >>> i # row indices -// array([[0], -// [1]]) -// >>> j # column indices -// array([[0, 1, 2]]) -// -// -// -//go:linkname Indices py.indices -func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object -// -// Construct an array by executing a function over each coordinate. -// -// The resulting array therefore has a value ``fn(x, y, z)`` at -// coordinate ``(x, y, z)``. -// -// Parameters -// ---------- -// function : callable -// The function is called with N parameters, where N is the rank of -// `shape`. Each parameter represents the coordinates of the array -// varying along a specific axis. For example, if `shape` -// were ``(2, 2)``, then the parameters would be -// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` -// shape : (N,) tuple of ints -// Shape of the output array, which also determines the shape of -// the coordinate arrays passed to `function`. -// dtype : data-type, optional -// Data-type of the coordinate arrays passed to `function`. -// By default, `dtype` is float. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// fromfunction : any -// The result of the call to `function` is passed back directly. -// Therefore the shape of `fromfunction` is completely determined by -// `function`. If `function` returns a scalar value, the shape of -// `fromfunction` would not match the `shape` parameter. -// -// See Also -// -------- -// indices, meshgrid -// -// Notes -// ----- -// Keywords other than `dtype` and `like` are passed to `function`. -// -// Examples -// -------- -// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) -// array([[0., 0.], -// [1., 1.]]) -// -// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) -// array([[0., 1.], -// [0., 1.]]) -// -// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) -// array([[ True, False, False], -// [False, True, False], -// [False, False, True]]) -// -// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) -// array([[0, 1, 2], -// [1, 2, 3], -// [2, 3, 4]]) -// -// -// -//go:linkname Fromfunction py.fromfunction -func Fromfunction(function *py.Object, shape *py.Object) *py.Object -// -// Returns True if the type of `element` is a scalar type. -// -// Parameters -// ---------- -// element : any -// Input argument, can be of any type and shape. -// -// Returns -// ------- -// val : bool -// True if `element` is a scalar type, False if it is not. -// -// See Also -// -------- -// ndim : Get the number of dimensions of an array -// -// Notes -// ----- -// If you need a stricter way to identify a *numerical* scalar, use -// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most -// non-numerical elements such as strings. -// -// In most 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: -// -// +--------------------------------------+---------------+-------------------+ -// | x |``isscalar(x)``|``np.ndim(x) == 0``| -// +======================================+===============+===================+ -// | PEP 3141 numeric objects (including | ``True`` | ``True`` | -// | builtins) | | | -// +--------------------------------------+---------------+-------------------+ -// | builtin string and buffer objects | ``True`` | ``True`` | -// +--------------------------------------+---------------+-------------------+ -// | other builtin objects, like | ``False`` | ``True`` | -// | `pathlib.Path`, `Exception`, | | | -// | the result of `re.compile` | | | -// +--------------------------------------+---------------+-------------------+ -// | third-party objects like | ``False`` | ``True`` | -// | `matplotlib.figure.Figure` | | | -// +--------------------------------------+---------------+-------------------+ -// | zero-dimensional numpy arrays | ``False`` | ``True`` | -// +--------------------------------------+---------------+-------------------+ -// | other numpy arrays | ``False`` | ``False`` | -// +--------------------------------------+---------------+-------------------+ -// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | -// | objects | | | -// +--------------------------------------+---------------+-------------------+ -// -// Examples -// -------- -// >>> np.isscalar(3.1) -// True -// >>> np.isscalar(np.array(3.1)) -// False -// >>> np.isscalar([3.1]) -// False -// >>> np.isscalar(False) -// True -// >>> np.isscalar('numpy') -// True -// -// NumPy supports PEP 3141 numbers: -// -// >>> from fractions import Fraction -// >>> np.isscalar(Fraction(5, 17)) -// True -// >>> from numbers import Number -// >>> np.isscalar(Number()) -// True -// -// -// -//go:linkname Isscalar py.isscalar -func Isscalar(element *py.Object) *py.Object -// -// Return the binary representation of the input number as a string. -// -// For negative numbers, if width is not given, a minus sign is added to the -// front. If width is given, the two's complement of the number is -// returned, with respect to that width. -// -// In a two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit two's-complement -// system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// num : int -// Only an integer decimal number can be used. -// width : int, optional -// The length of the returned string if `num` is positive, or the length -// of the two's complement if `num` is negative, provided that `width` is -// at least a sufficient number of bits for `num` to be represented in the -// designated form. -// -// If the `width` value is insufficient, it will be ignored, and `num` will -// be returned in binary (`num` > 0) or two's complement (`num` < 0) form -// with its width equal to the minimum number of bits needed to represent -// the number in the designated form. This behavior is deprecated and will -// later raise an error. -// -// .. deprecated:: 1.12.0 -// -// Returns -// ------- -// bin : str -// Binary representation of `num` or two's complement of `num`. -// -// See Also -// -------- -// base_repr: Return a string representation of a number in the given base -// system. -// bin: Python's built-in binary representation generator of an integer. -// -// Notes -// ----- -// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x -// faster. -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// >>> np.binary_repr(3) -// '11' -// >>> np.binary_repr(-3) -// '-11' -// >>> np.binary_repr(3, width=4) -// '0011' -// -// The two's complement is returned when the input number is negative and -// width is specified: -// -// >>> np.binary_repr(-3, width=3) -// '101' -// >>> np.binary_repr(-3, width=5) -// '11101' -// -// -// -//go:linkname BinaryRepr py.binary_repr -func BinaryRepr(num *py.Object, width *py.Object) *py.Object -// -// Return a string representation of a number in the given base system. -// -// Parameters -// ---------- -// number : int -// The value to convert. Positive and negative values are handled. -// base : int, optional -// Convert `number` to the `base` number system. The valid range is 2-36, -// the default value is 2. -// padding : int, optional -// Number of zeros padded on the left. Default is 0 (no padding). -// -// Returns -// ------- -// out : str -// String representation of `number` in `base` system. -// -// See Also -// -------- -// binary_repr : Faster version of `base_repr` for base 2. -// -// Examples -// -------- -// >>> np.base_repr(5) -// '101' -// >>> np.base_repr(6, 5) -// '11' -// >>> np.base_repr(7, base=5, padding=3) -// '00012' -// -// >>> np.base_repr(10, base=16) -// 'A' -// >>> np.base_repr(32, base=16) -// '20' -// -// -// -//go:linkname BaseRepr py.base_repr -func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object -// -// Return a new array of given shape and type, filled with ones. -// -// Parameters -// ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// The desired data-type for the array, e.g., `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: C -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of ones with the given shape, dtype, and order. -// -// See Also -// -------- -// ones_like : Return an array of ones with shape and type of input. -// empty : Return a new uninitialized array. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. -// -// -// Examples -// -------- -// >>> np.ones(5) -// array([1., 1., 1., 1., 1.]) -// -// >>> np.ones((5,), dtype=int) -// array([1, 1, 1, 1, 1]) -// -// >>> np.ones((2, 1)) -// array([[1.], -// [1.]]) -// -// >>> s = (2,2) -// >>> np.ones(s) -// array([[1., 1.], -// [1., 1.]]) -// -// -// -//go:linkname Ones py.ones -func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Return the identity array. -// -// The identity array is a square array with ones on -// the main diagonal. -// -// Parameters -// ---------- -// n : int -// Number of rows (and columns) in `n` x `n` output. -// dtype : data-type, optional -// Data-type of the output. Defaults to ``float``. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// `n` x `n` array with its main diagonal set to one, -// and all other elements 0. -// -// Examples -// -------- -// >>> np.identity(3) -// array([[1., 0., 0.], -// [0., 1., 0.], -// [0., 0., 1.]]) -// -// -// -//go:linkname Identity py.identity -func Identity(n *py.Object, dtype *py.Object) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute bit-wise inversion, or bit-wise NOT, element-wise. -// -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. -// -// For signed integer inputs, the two's complement is returned. In a -// two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit -// two's-complement system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Notes -// ----- -// `bitwise_not` is an alias for `invert`: -// -// >>> np.bitwise_not is np.invert -// True -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: -// -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// 242 -// >>> np.binary_repr(x, width=8) -// '11110010' -// -// The result depends on the bit-width: -// -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// 65522 -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types the result is the two's complement of -// the result for the unsigned type: -// -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' -// -// Booleans are accepted as well: -// -// >>> np.invert(np.array([True, False])) -// array([False, True]) -// -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. -// -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) -// -//go:linkname BitwiseNot py.bitwise_not -func BitwiseNot(__llgo_va_list ...interface{}) *py.Object -// -// Return a new array of given shape and type, filled with `fill_value`. -// -// Parameters -// ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// fill_value : scalar or array_like -// Fill value. -// dtype : data-type, optional -// The desired data-type for the array The default, None, means -// ``np.array(fill_value).dtype``. -// order : {'C', 'F'}, optional -// Whether to store multidimensional data in C- or Fortran-contiguous -// (row- or column-wise) order in memory. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of `fill_value` with the given shape, dtype, and order. -// -// See Also -// -------- -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. -// -// Examples -// -------- -// >>> np.full((2, 2), np.inf) -// array([[inf, inf], -// [inf, inf]]) -// >>> np.full((2, 2), 10) -// array([[10, 10], -// [10, 10]]) -// -// >>> np.full((2, 2), [1, 2]) -// array([[1, 2], -// [1, 2]]) -// -// -// -//go:linkname Full py.full -func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object -// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) -// -// Matrix product of two arrays. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays, scalars not allowed. -// out : ndarray, optional -// A location into which the result is stored. If provided, it must have -// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not -// provided or None, a freshly-allocated array is returned. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// .. versionadded:: 1.16 -// Now handles ufunc kwargs -// -// Returns -// ------- -// y : ndarray -// The matrix product of the inputs. -// This is a scalar only when both x1, x2 are 1-d vectors. -// -// Raises -// ------ -// ValueError -// If the last dimension of `x1` is not the same size as -// the second-to-last dimension of `x2`. -// -// If a scalar value is passed in. -// -// See Also -// -------- -// vdot : Complex-conjugating dot product. -// tensordot : Sum products over arbitrary axes. -// einsum : Einstein summation convention. -// dot : alternative matrix product with different broadcasting rules. -// -// Notes -// ----- -// -// The behavior depends on the arguments in the following way. -// -// - If both arguments are 2-D they are multiplied like conventional -// matrices. -// - If either argument is N-D, N > 2, it is treated as a stack of -// matrices residing in the last two indexes and broadcast accordingly. -// - If the first argument is 1-D, it is promoted to a matrix by -// prepending a 1 to its dimensions. After matrix multiplication -// the prepended 1 is removed. -// - If the second argument is 1-D, it is promoted to a matrix by -// appending a 1 to its dimensions. After matrix multiplication -// the appended 1 is removed. -// -// ``matmul`` differs from ``dot`` in two important ways: -// -// - Multiplication by scalars is not allowed, use ``*`` instead. -// - Stacks of matrices are broadcast together as if the matrices -// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: -// -// >>> a = np.ones([9, 5, 7, 4]) -// >>> c = np.ones([9, 5, 4, 3]) -// >>> np.dot(a, c).shape -// (9, 5, 7, 9, 5, 3) -// >>> np.matmul(a, c).shape -// (9, 5, 7, 3) -// >>> # n is 7, k is 4, m is 3 -// -// The matmul function implements the semantics of the ``@`` operator -// introduced in Python 3.5 following :pep:`465`. -// -// It uses an optimized BLAS library when possible (see `numpy.linalg`). -// -// Examples -// -------- -// For 2-D arrays it is the matrix product: -// -// >>> a = np.array([[1, 0], -// ... [0, 1]]) -// >>> b = np.array([[4, 1], -// ... [2, 2]]) -// >>> np.matmul(a, b) -// array([[4, 1], -// [2, 2]]) -// -// For 2-D mixed with 1-D, the result is the usual. -// -// >>> a = np.array([[1, 0], -// ... [0, 1]]) -// >>> b = np.array([1, 2]) -// >>> np.matmul(a, b) -// array([1, 2]) -// >>> np.matmul(b, a) -// array([1, 2]) -// -// -// Broadcasting is conventional for stacks of arrays -// -// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) -// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) -// >>> np.matmul(a,b).shape -// (2, 2, 2) -// >>> np.matmul(a, b)[0, 1, 1] -// 98 -// >>> sum(a[0, 1, :] * b[0 , :, 1]) -// 98 -// -// Vector, vector returns the scalar inner product, but neither argument -// is complex-conjugated: -// -// >>> np.matmul([2j, 3j], [2j, 3j]) -// (-13+0j) -// -// Scalar multiplication raises an error. -// -// >>> np.matmul([1,2], 3) -// Traceback (most recent call last): -// ... -// ValueError: matmul: Input operand 1 does not have enough dimensions ... -// -// The ``@`` operator can be used as a shorthand for ``np.matmul`` on -// ndarrays. -// -// >>> x1 = np.array([2j, 3j]) -// >>> x2 = np.array([2j, 3j]) -// >>> x1 @ x2 -// (-13+0j) -// -// .. versionadded:: 1.10.0 -// -//go:linkname Matmul py.matmul -func Matmul(__llgo_va_list ...interface{}) *py.Object -// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the absolute value element-wise. -// -// ``np.abs`` is a shorthand for this function. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// absolute : ndarray -// An ndarray containing the absolute value of -// each element in `x`. For complex input, ``a + ib``, the -// absolute value is :math:`\sqrt{ a^2 + b^2 }`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> x = np.array([-1.2, 1.2]) -// >>> np.absolute(x) -// array([ 1.2, 1.2]) -// >>> np.absolute(1.2 + 1j) -// 1.5620499351813308 -// -// Plot the function over ``[-10, 10]``: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(start=-10, stop=10, num=101) -// >>> plt.plot(x, np.absolute(x)) -// >>> plt.show() -// -// Plot the function over the complex plane: -// -// >>> xx = x + 1j * x[:, np.newaxis] -// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') -// >>> plt.show() -// -// The `abs` function can be used as a shorthand for ``np.absolute`` on -// ndarrays. -// -// >>> x = np.array([-1.2, 1.2]) -// >>> abs(x) -// array([1.2, 1.2]) -// -//go:linkname Absolute py.absolute -func Absolute(__llgo_va_list ...interface{}) *py.Object -// add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Add arguments element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays to be added. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// add : ndarray or scalar -// The sum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to `x1` + `x2` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.add(1.0, 4.0) -// 5.0 -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.add(x1, x2) -// array([[ 0., 2., 4.], -// [ 3., 5., 7.], -// [ 6., 8., 10.]]) -// -// The ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 + x2 -// array([[ 0., 2., 4.], -// [ 3., 5., 7.], -// [ 6., 8., 10.]]) -// -//go:linkname Add py.add -func Add(__llgo_va_list ...interface{}) *py.Object -// arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric inverse cosine, element-wise. -// -// The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``. -// -// Parameters -// ---------- -// x : array_like -// `x`-coordinate on the unit circle. -// For real arguments, the domain is [-1, 1]. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// The angle of the ray intersecting the unit circle at the given -// `x`-coordinate in radians [0, pi]. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// cos, arctan, arcsin, emath.arccos -// -// Notes -// ----- -// `arccos` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``cos(z) = x``. The convention is to return -// the angle `z` whose real part lies in `[0, pi]`. -// -// For real-valued input data types, `arccos` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse `cos` is also known as `acos` or cos^-1. -// -// References -// ---------- -// M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// We expect the arccos of 1 to be 0, and of -1 to be pi: -// -// >>> np.arccos([1, -1]) -// array([ 0. , 3.14159265]) -// -// Plot arccos: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-1, 1, num=100) -// >>> plt.plot(x, np.arccos(x)) -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Arccos py.arccos -func Arccos(__llgo_va_list ...interface{}) *py.Object -// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic cosine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// arccosh : ndarray -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// -// cosh, arcsinh, sinh, arctanh, tanh -// -// Notes -// ----- -// `arccosh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `cosh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in -// ``[0, inf]``. -// -// For real-valued input data types, `arccosh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arccosh` is a complex analytical function that -// has a branch cut `[-inf, 1]` and is continuous from above on it. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arccosh -// -// Examples -// -------- -// >>> np.arccosh([np.e, 10.0]) -// array([ 1.65745445, 2.99322285]) -// >>> np.arccosh(1) -// 0.0 -// -//go:linkname Arccosh py.arccosh -func Arccosh(__llgo_va_list ...interface{}) *py.Object -// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse sine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// `y`-coordinate on the unit circle. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// The inverse sine of each element in `x`, in radians and in the -// closed interval ``[-pi/2, pi/2]``. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin -// -// Notes -// ----- -// `arcsin` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that :math:`sin(z) = x`. The convention is to -// return the angle `z` whose real part lies in [-pi/2, pi/2]. -// -// For real-valued input data types, *arcsin* always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse sine is also known as `asin` or sin^{-1}. -// -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79ff. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// >>> np.arcsin(1) # pi/2 -// 1.5707963267948966 -// >>> np.arcsin(-1) # -pi/2 -// -1.5707963267948966 -// >>> np.arcsin(0) -// 0.0 -// -//go:linkname Arcsin py.arcsin -func Arcsin(__llgo_va_list ...interface{}) *py.Object -// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic sine element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `arcsinh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `sinh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arcsinh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// returns ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arcsinh -// -// Examples -// -------- -// >>> np.arcsinh(np.array([np.e, 10.0])) -// array([ 1.72538256, 2.99822295]) -// -//go:linkname Arcsinh py.arcsinh -func Arcsinh(__llgo_va_list ...interface{}) *py.Object -// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric inverse tangent, element-wise. -// -// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. -// -// Parameters -// ---------- -// x : array_like -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Out has the same shape as `x`. Its real part is in -// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) -// and the positive `x`-axis. -// angle : Argument of complex values. -// -// Notes -// ----- -// `arctan` is a multi-valued function: for each `x` there are infinitely -// many numbers `z` such that tan(`z`) = `x`. The convention is to return -// the angle `z` whose real part lies in [-pi/2, pi/2]. -// -// For real-valued input data types, `arctan` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse tangent is also known as `atan` or tan^{-1}. -// -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// We expect the arctan of 0 to be 0, and of 1 to be pi/4: -// -// >>> np.arctan([0, 1]) -// array([ 0. , 0.78539816]) -// -// >>> np.pi/4 -// 0.78539816339744828 -// -// Plot arctan: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-10, 10) -// >>> plt.plot(x, np.arctan(x)) -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Arctan py.arctan -func Arctan(__llgo_va_list ...interface{}) *py.Object -// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. -// -// 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`). (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). -// -// This function is not defined for complex-valued arguments; for the -// so-called argument of complex values, use `angle`. -// -// Parameters -// ---------- -// x1 : array_like, real-valued -// `y`-coordinates. -// x2 : array_like, real-valued -// `x`-coordinates. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// Array of angles in radians, in the range ``[-pi, pi]``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// arctan, tan, angle -// -// Notes -// ----- -// *arctan2* is identical to the `atan2` function of the underlying -// C library. The following special values are defined in the C -// standard: [1]_ -// -// ====== ====== ================ -// `x1` `x2` `arctan2(x1,x2)` -// ====== ====== ================ -// +/- 0 +0 +/- 0 -// +/- 0 -0 +/- pi -// > 0 +/-inf +0 / +pi -// < 0 +/-inf -0 / -pi -// +/-inf +inf +/- (pi/4) -// +/-inf -inf +/- (3*pi/4) -// ====== ====== ================ -// -// Note that +0 and -0 are distinct floating point numbers, as are +inf -// and -inf. -// -// References -// ---------- -// .. [1] ISO/IEC standard 9899:1999, "Programming language C." -// -// Examples -// -------- -// Consider four points in different quadrants: -// -// >>> x = np.array([-1, +1, +1, -1]) -// >>> y = np.array([-1, -1, +1, +1]) -// >>> np.arctan2(y, x) * 180 / np.pi -// array([-135., -45., 45., 135.]) -// -// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 -// and at several other special points, obtaining values in -// the range ``[-pi, pi]``: -// -// >>> np.arctan2([1., -1.], [0., 0.]) -// array([ 1.57079633, -1.57079633]) -// >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) -// array([0. , 3.14159265, 0.78539816]) -// -//go:linkname Arctan2 py.arctan2 -func Arctan2(__llgo_va_list ...interface{}) *py.Object -// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic tangent element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.arctanh -// -// Notes -// ----- -// `arctanh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``tanh(z) = x``. The convention is to return -// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arctanh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// 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. -// -// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arctanh -// -// Examples -// -------- -// >>> np.arctanh([0, -0.5]) -// array([ 0. , -0.54930614]) -// -//go:linkname Arctanh py.arctanh -func Arctanh(__llgo_va_list ...interface{}) *py.Object -// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise AND of two arrays element-wise. -// -// Computes the bit-wise AND of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``&``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and -// bitwise_or -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise AND of 13 and 17 is -// therefore ``000000001``, or 1: -// -// >>> np.bitwise_and(13, 17) -// 1 -// -// >>> np.bitwise_and(14, 13) -// 12 -// >>> np.binary_repr(12) -// '1100' -// >>> np.bitwise_and([14,3], 13) -// array([12, 1]) -// -// >>> np.bitwise_and([11,7], [4,25]) -// array([0, 1]) -// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) -// array([ 2, 4, 16]) -// >>> np.bitwise_and([True, True], [False, True]) -// array([False, True]) -// -// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([3, 14, 16]) -// >>> x1 & x2 -// array([ 2, 4, 16]) -// -//go:linkname BitwiseAnd py.bitwise_and -func BitwiseAnd(__llgo_va_list ...interface{}) *py.Object -// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise OR of two arrays element-wise. -// -// Computes the bit-wise OR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``|``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_or -// bitwise_and -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 has the binary representation ``00001101``. Likewise, -// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is -// then ``00011101``, or 29: -// -// >>> np.bitwise_or(13, 16) -// 29 -// >>> np.binary_repr(29) -// '11101' -// -// >>> np.bitwise_or(32, 2) -// 34 -// >>> np.bitwise_or([33, 4], 1) -// array([33, 5]) -// >>> np.bitwise_or([33, 4], [1, 2]) -// array([33, 6]) -// -// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) -// array([ 6, 5, 255]) -// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) -// array([ 6, 5, 255]) -// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), -// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) -// array([ 6, 5, 255, 2147483647]) -// >>> np.bitwise_or([True, True], [False, True]) -// array([ True, True]) -// -// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([4, 4, 4]) -// >>> x1 | x2 -// array([ 6, 5, 255]) -// -//go:linkname BitwiseOr py.bitwise_or -func BitwiseOr(__llgo_va_list ...interface{}) *py.Object -// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise XOR of two arrays element-wise. -// -// Computes the bit-wise XOR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``^``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_xor -// bitwise_and -// bitwise_or -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise XOR of 13 and 17 is -// therefore ``00011100``, or 28: -// -// >>> np.bitwise_xor(13, 17) -// 28 -// >>> np.binary_repr(28) -// '11100' -// -// >>> np.bitwise_xor(31, 5) -// 26 -// >>> np.bitwise_xor([31,3], 5) -// array([26, 6]) -// -// >>> np.bitwise_xor([31,3], [5,6]) -// array([26, 5]) -// >>> np.bitwise_xor([True, True], [False, True]) -// array([ True, False]) -// -// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on -// ndarrays. -// -// >>> x1 = np.array([True, True]) -// >>> x2 = np.array([False, True]) -// >>> x1 ^ x2 -// array([ True, False]) -// -//go:linkname BitwiseXor py.bitwise_xor -func BitwiseXor(__llgo_va_list ...interface{}) *py.Object -// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the cube-root of an array, element-wise. -// -// .. versionadded:: 1.10.0 -// -// Parameters -// ---------- -// x : array_like -// The values whose cube-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the cube -// cube-root of each element in `x`. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. -// -// -// Examples -// -------- -// >>> np.cbrt([1,8,27]) -// array([ 1., 2., 3.]) -// -//go:linkname Cbrt py.cbrt -func Cbrt(__llgo_va_list ...interface{}) *py.Object -// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the ceiling of the input, element-wise. -// -// The ceil of the scalar `x` is the smallest integer `i`, such that -// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The ceiling of each element in `x`, with `float` dtype. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// floor, trunc, rint, fix -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.ceil(a) -// array([-1., -1., -0., 1., 2., 2., 2.]) -// -//go:linkname Ceil py.ceil -func Ceil(__llgo_va_list ...interface{}) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the complex conjugate, element-wise. -// -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `conj` is an alias for `conjugate`: -// -// >>> np.conj is np.conjugate -// True -// -// Examples -// -------- -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conj py.conj -func Conj(__llgo_va_list ...interface{}) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the complex conjugate, element-wise. -// -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `conj` is an alias for `conjugate`: -// -// >>> np.conj is np.conjugate -// True -// -// Examples -// -------- -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conjugate py.conjugate -func Conjugate(__llgo_va_list ...interface{}) *py.Object -// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Change the sign of x1 to that of x2, element-wise. -// -// If `x2` is a scalar, its sign will be copied to all elements of `x1`. -// -// Parameters -// ---------- -// x1 : array_like -// Values to change the sign of. -// x2 : array_like -// The sign of `x2` is copied to `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The values of `x1` with the sign of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> np.copysign(1.3, -1) -// -1.3 -// >>> 1/np.copysign(0, 1) -// inf -// >>> 1/np.copysign(0, -1) -// -inf -// -// >>> np.copysign([-1, 0, 1], -1.1) -// array([-1., -0., -1.]) -// >>> np.copysign([-1, 0, 1], np.arange(3)-1) -// array([-1., 0., 1.]) -// -//go:linkname Copysign py.copysign -func Copysign(__llgo_va_list ...interface{}) *py.Object -// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Cosine element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding cosine values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. -// -// Examples -// -------- -// >>> np.cos(np.array([0, np.pi/2, np.pi])) -// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) -// >>> -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Cos py.cos -func Cos(__llgo_va_list ...interface{}) *py.Object -// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Hyperbolic cosine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array of same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.cosh(0) -// 1.0 -// -// The hyperbolic cosine describes the shape of a hanging cable: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-4, 4, 1000) -// >>> plt.plot(x, np.cosh(x)) -// >>> plt.show() -// -//go:linkname Cosh py.cosh -func Cosh(__llgo_va_list ...interface{}) *py.Object -// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from degrees to radians. -// -// Parameters -// ---------- -// x : array_like -// Angles in degrees. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in radians. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// rad2deg : Convert angles from radians to degrees. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// ``deg2rad(x)`` is ``x * pi / 180``. -// -// Examples -// -------- -// >>> np.deg2rad(180) -// 3.1415926535897931 -// -//go:linkname Deg2rad py.deg2rad -func Deg2rad(__llgo_va_list ...interface{}) *py.Object -// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray of floats -// The corresponding degree values; if `out` was supplied this is a -// reference to it. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// rad2deg : equivalent function -// -// Examples -// -------- -// Convert a radian array to degrees -// -// >>> rad = np.arange(12.)*np.pi/6 -// >>> np.degrees(rad) -// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., -// 270., 300., 330.]) -// -// >>> out = np.zeros((rad.shape)) -// >>> r = np.degrees(rad, out) -// >>> np.all(r == out) -// True -// -//go:linkname Degrees py.degrees -func Degrees(__llgo_va_list ...interface{}) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Divide arguments element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. -// -// Examples -// -------- -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.divide(x1, x2) -// array([[nan, 1. , 1. ], -// [inf, 4. , 2.5], -// [inf, 7. , 4. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) -// -//go:linkname Divide py.divide -func Divide(__llgo_va_list ...interface{}) *py.Object -// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return element-wise quotient and remainder simultaneously. -// -// .. versionadded:: 1.13.0 -// -// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster -// because it avoids redundant work. It is used to implement the Python -// built-in function ``divmod`` on NumPy arrays. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out1 : ndarray -// Element-wise quotient resulting from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// out2 : ndarray -// Element-wise remainder from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent to Python's ``//`` operator. -// remainder : Equivalent to Python's ``%`` operator. -// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return -// values switched. -// -// Examples -// -------- -// >>> np.divmod(np.arange(5), 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) -// -// The `divmod` function can be used as a shorthand for ``np.divmod`` on -// ndarrays. -// -// >>> x = np.arange(5) -// >>> divmod(x, 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) -// -//go:linkname Divmod py.divmod -func Divmod(__llgo_va_list ...interface{}) *py.Object -// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return (x1 == x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// not_equal, greater_equal, less_equal, greater, less -// -// Examples -// -------- -// >>> np.equal([0, 1, 3], np.arange(3)) -// array([ True, True, False]) -// -// What is compared are values, not types. So an int (1) and an array of -// length one can evaluate as True: -// -// >>> np.equal(1, np.ones(1)) -// array([ True]) -// -// The ``==`` operator can be used as a shorthand for ``np.equal`` on -// ndarrays. -// -// >>> a = np.array([2, 4, 6]) -// >>> b = np.array([2, 4, 2]) -// >>> a == b -// array([ True, True, False]) -// -//go:linkname Equal py.equal -func Equal(__llgo_va_list ...interface{}) *py.Object -// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the exponential of all elements in the input array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise exponential of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. -// exp2 : Calculate ``2**x`` for all elements in the array. -// -// Notes -// ----- -// The irrational number ``e`` is also known as Euler's number. It is -// approximately 2.718281, and is the base of the natural logarithm, -// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, -// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. -// -// For complex arguments, ``x = a + ib``, we can write -// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already -// known (it is the real argument, described above). The second term, -// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with -// magnitude 1 and a periodic phase. -// -// References -// ---------- -// .. [1] Wikipedia, "Exponential function", -// https://en.wikipedia.org/wiki/Exponential_function -// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions -// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, -// https://personal.math.ubc.ca/~cbm/aands/page_69.htm -// -// Examples -// -------- -// Plot the magnitude and phase of ``exp(x)`` in the complex plane: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) -// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane -// >>> out = np.exp(xx) -// -// >>> plt.subplot(121) -// >>> plt.imshow(np.abs(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') -// >>> plt.title('Magnitude of exp(x)') -// -// >>> plt.subplot(122) -// >>> plt.imshow(np.angle(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') -// >>> plt.title('Phase (angle) of exp(x)') -// >>> plt.show() -// -//go:linkname Exp py.exp -func Exp(__llgo_va_list ...interface{}) *py.Object -// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate `2**p` for all `p` in the input array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise 2 to the power `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// power -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// -// -// Examples -// -------- -// >>> np.exp2([2, 3]) -// array([ 4., 8.]) -// -//go:linkname Exp2 py.exp2 -func Exp2(__llgo_va_list ...interface{}) *py.Object -// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate ``exp(x) - 1`` for all elements in the array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise exponential minus one: ``out = exp(x) - 1``. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log1p : ``log(1 + x)``, the inverse of expm1. -// -// -// Notes -// ----- -// This function provides greater precision than ``exp(x) - 1`` -// for small values of ``x``. -// -// Examples -// -------- -// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to -// about 32 significant digits. This example shows the superiority of -// expm1 in this case. -// -// >>> np.expm1(1e-10) -// 1.00000000005e-10 -// >>> np.exp(1e-10) - 1 -// 1.000000082740371e-10 -// -//go:linkname Expm1 py.expm1 -func Expm1(__llgo_va_list ...interface{}) *py.Object -// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the absolute values element-wise. -// -// This function returns the absolute values (positive magnitude) of the -// data in `x`. Complex values are not handled, use `absolute` to find the -// absolute values of complex data. -// -// Parameters -// ---------- -// x : array_like -// The array of numbers for which the absolute values are required. If -// `x` is a scalar, the result `y` will also be a scalar. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The absolute values of `x`, the returned values are always floats. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// absolute : Absolute values including `complex` types. -// -// Examples -// -------- -// >>> np.fabs(-1) -// 1.0 -// >>> np.fabs([-1.2, 1.2]) -// array([ 1.2, 1.2]) -// -//go:linkname Fabs py.fabs -func Fabs(__llgo_va_list ...interface{}) *py.Object -// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the floor of the input, element-wise. -// -// The floor of the scalar `x` is the largest integer `i`, such that -// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The floor of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ceil, trunc, rint, fix -// -// Notes -// ----- -// Some spreadsheet programs calculate the "floor-towards-zero", where -// ``floor(-2.5) == -2``. NumPy instead uses the definition of -// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" -// function is called ``fix`` in NumPy. -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.floor(a) -// array([-2., -2., -1., 0., 1., 1., 2.]) -// -//go:linkname Floor py.floor -func Floor(__llgo_va_list ...interface{}) *py.Object -// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the largest integer smaller or equal to the division of the inputs. -// It is equivalent to the Python ``//`` operator and pairs with the -// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` -// up to roundoff. -// -// Parameters -// ---------- -// x1 : array_like -// Numerator. -// x2 : array_like -// Denominator. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// y = floor(`x1`/`x2`) -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// remainder : Remainder complementary to floor_divide. -// divmod : Simultaneous floor division and remainder. -// divide : Standard division. -// floor : Round a number to the nearest integer toward minus infinity. -// ceil : Round a number to the nearest integer toward infinity. -// -// Examples -// -------- -// >>> np.floor_divide(7,3) -// 2 -// >>> np.floor_divide([1., 2., 3., 4.], 2.5) -// array([ 0., 0., 1., 1.]) -// -// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` -// on ndarrays. -// -// >>> x1 = np.array([1., 2., 3., 4.]) -// >>> x1 // 2.5 -// array([0., 0., 1., 1.]) -// -//go:linkname FloorDivide py.floor_divide -func FloorDivide(__llgo_va_list ...interface{}) *py.Object -// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// First array elements raised to powers from second array, element-wise. -// -// Raise each base in `x1` to the positionally-corresponding power in `x2`. -// `x1` and `x2` must be broadcastable to the same shape. This differs from -// the power function in that integers, float16, and float32 are promoted to -// floats with a minimum precision of float64 so that the result is always -// inexact. The intent is that the function will return a usable result for -// negative powers and seldom overflow for positive powers. -// -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). -// -// .. versionadded:: 1.12.0 -// -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// power : power function that preserves type -// -// Examples -// -------- -// Cube each element in a list. -// -// >>> x1 = range(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.float_power(x1, 3) -// array([ 0., 1., 8., 27., 64., 125.]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.float_power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.float_power(x1, x2) -// array([[ 0., 1., 8., 27., 16., 5.], -// [ 0., 1., 8., 27., 16., 5.]]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1, -4]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.float_power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.float_power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname FloatPower py.float_power -func FloatPower(__llgo_va_list ...interface{}) *py.Object -// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise maximum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// minimum, amin, nanmin -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. -// -// Examples -// -------- -// >>> np.fmax([2, 3, 4], [1, 5, 2]) -// array([ 2., 5., 4.]) -// -// >>> np.fmax(np.eye(2), [0.5, 2]) -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) -// -// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) -// -//go:linkname Fmax py.fmax -func Fmax(__llgo_va_list ...interface{}) *py.Object -// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise minimum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. -// -// maximum, amax, nanmax -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. -// -// Examples -// -------- -// >>> np.fmin([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) -// -// >>> np.fmin(np.eye(2), [0.5, 2]) -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) -// -// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) -// -//go:linkname Fmin py.fmin -func Fmin(__llgo_va_list ...interface{}) *py.Object -// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// This is the NumPy implementation of the C library function fmod, the -// remainder has the same sign as the dividend `x1`. It is equivalent to -// the Matlab(TM) ``rem`` function and should not be confused with the -// Python modulus operator ``x1 % x2``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend. -// x2 : array_like -// Divisor. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : array_like -// The remainder of the division of `x1` by `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// remainder : Equivalent to the Python ``%`` operator. -// divide -// -// Notes -// ----- -// The result of the modulo operation for negative dividend and divisors -// is bound by conventions. For `fmod`, the sign of result is the sign of -// the dividend, while for `remainder` the sign of the result is the sign -// of the divisor. The `fmod` function is equivalent to the Matlab(TM) -// ``rem`` function. -// -// Examples -// -------- -// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) -// array([-1, 0, -1, 1, 0, 1]) -// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) -// array([1, 0, 1, 1, 0, 1]) -// -// >>> np.fmod([5, 3], [2, 2.]) -// array([ 1., 1.]) -// >>> a = np.arange(-3, 3).reshape(3, 2) -// >>> a -// array([[-3, -2], -// [-1, 0], -// [ 1, 2]]) -// >>> np.fmod(a, [2,2]) -// array([[-1, 0], -// [-1, 0], -// [ 1, 0]]) -// -//go:linkname Fmod py.fmod -func Fmod(__llgo_va_list ...interface{}) *py.Object -// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Decompose the elements of x into mantissa and twos exponent. -// -// Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``. -// The mantissa lies in the open interval(-1, 1), while the twos -// exponent is a signed integer. -// -// Parameters -// ---------- -// x : array_like -// Array of numbers to be decomposed. -// out1 : ndarray, optional -// Output array for the mantissa. Must have the same shape as `x`. -// out2 : ndarray, optional -// Output array for the exponent. Must have the same shape as `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// mantissa : ndarray -// Floating values between -1 and 1. -// This is a scalar if `x` is a scalar. -// exponent : ndarray -// Integer exponents of 2. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`. -// -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. -// -// Examples -// -------- -// >>> x = np.arange(9) -// >>> y1, y2 = np.frexp(x) -// >>> y1 -// array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, -// 0.5 ]) -// >>> y2 -// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) -// >>> y1 * 2**y2 -// array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) -// -//go:linkname Frexp py.frexp -func Frexp(__llgo_va_list ...interface{}) *py.Object -// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the Heaviside step function. -// -// The Heaviside step function is defined as:: -// -// 0 if x1 < 0 -// heaviside(x1, x2) = x2 if x1 == 0 -// 1 if x1 > 0 -// -// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. -// -// Parameters -// ---------- -// x1 : array_like -// Input values. -// x2 : array_like -// The value of the function when x1 is 0. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The output array, element-wise Heaviside step function of `x1`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// .. versionadded:: 1.13.0 -// -// References -// ---------- -// .. Wikipedia, "Heaviside step function", -// https://en.wikipedia.org/wiki/Heaviside_step_function -// -// Examples -// -------- -// >>> np.heaviside([-1.5, 0, 2.0], 0.5) -// array([ 0. , 0.5, 1. ]) -// >>> np.heaviside([-1.5, 0, 2.0], 1) -// array([ 0., 1., 1.]) -// -//go:linkname Heaviside py.heaviside -func Heaviside(__llgo_va_list ...interface{}) *py.Object -// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Given the "legs" of a right triangle, return its hypotenuse. -// -// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. 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. -// (See Examples) -// -// Parameters -// ---------- -// x1, x2 : array_like -// Leg of the triangle(s). -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// z : ndarray -// The hypotenuse of the triangle(s). -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) -// -// Example showing broadcast of scalar_like argument: -// -// >>> np.hypot(3*np.ones((3, 3)), [4]) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) -// -//go:linkname Hypot py.hypot -func Hypot(__llgo_va_list ...interface{}) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute bit-wise inversion, or bit-wise NOT, element-wise. -// -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. -// -// For signed integer inputs, the two's complement is returned. In a -// two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit -// two's-complement system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Notes -// ----- -// `bitwise_not` is an alias for `invert`: -// -// >>> np.bitwise_not is np.invert -// True -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: -// -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// 242 -// >>> np.binary_repr(x, width=8) -// '11110010' -// -// The result depends on the bit-width: -// -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// 65522 -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types the result is the two's complement of -// the result for the unsigned type: -// -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' -// -// Booleans are accepted as well: -// -// >>> np.invert(np.array([True, False])) -// array([False, True]) -// -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. -// -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) -// -//go:linkname Invert py.invert -func Invert(__llgo_va_list ...interface{}) *py.Object -// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for finiteness (not infinity and not Not a Number). -// -// The result is returned as a boolean array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray, bool -// True where ``x`` is not positive infinity, negative infinity, -// or NaN; false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isinf, isneginf, isposinf, isnan -// -// 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. -// -// Examples -// -------- -// >>> np.isfinite(1) -// True -// >>> np.isfinite(0) -// True -// >>> np.isfinite(np.nan) -// False -// >>> np.isfinite(np.inf) -// False -// >>> np.isfinite(np.NINF) -// False -// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) -// array([False, True, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isfinite(x, y) -// array([0, 1, 0]) -// >>> y -// array([0, 1, 0]) -// -//go:linkname Isfinite py.isfinite -func Isfinite(__llgo_va_list ...interface{}) *py.Object -// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for positive or negative infinity. -// -// Returns a boolean array of the same shape as `x`, True where ``x == -// +/-inf``, otherwise False. -// -// Parameters -// ---------- -// x : array_like -// Input values -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool (scalar) or boolean ndarray -// True where ``x`` is positive or negative infinity, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isneginf, isposinf, isnan, isfinite -// -// 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. -// -// Examples -// -------- -// >>> np.isinf(np.inf) -// True -// >>> np.isinf(np.nan) -// False -// >>> np.isinf(np.NINF) -// True -// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) -// array([ True, True, False, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isinf(x, y) -// array([1, 0, 1]) -// >>> y -// array([1, 0, 1]) -// -//go:linkname Isinf py.isinf -func Isinf(__llgo_va_list ...interface{}) *py.Object -// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for NaN and return result as a boolean array. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaN, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isinf, isneginf, isposinf, isfinite, isnat -// -// 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. -// -// Examples -// -------- -// >>> np.isnan(np.nan) -// True -// >>> np.isnan(np.inf) -// False -// >>> np.isnan([np.log(-1.),1.,np.log(0)]) -// array([ True, False, False]) -// -//go:linkname Isnan py.isnan -func Isnan(__llgo_va_list ...interface{}) *py.Object -// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for NaT (not a time) and return result as a boolean array. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// x : array_like -// Input array with datetime or timedelta data type. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaT, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isnan, isinf, isneginf, isposinf, isfinite -// -// Examples -// -------- -// >>> np.isnat(np.datetime64("NaT")) -// True -// >>> np.isnat(np.datetime64("2016-01-01")) -// False -// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) -// array([ True, False]) -// -//go:linkname Isnat py.isnat -func Isnat(__llgo_va_list ...interface{}) *py.Object -// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` -// -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The lowest common multiple of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// gcd : The greatest common divisor -// -// Examples -// -------- -// >>> np.lcm(12, 20) -// 60 -// >>> np.lcm.reduce([3, 12, 20]) -// 60 -// >>> np.lcm.reduce([40, 12, 20]) -// 120 -// >>> np.lcm(np.arange(6), 20) -// array([ 0, 20, 20, 60, 20, 20]) -// -//go:linkname Lcm py.lcm -func Lcm(__llgo_va_list ...interface{}) *py.Object -// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns x1 * 2**x2, element-wise. -// -// The mantissas `x1` and twos exponents `x2` are used to construct -// floating point numbers ``x1 * 2**x2``. -// -// Parameters -// ---------- -// x1 : array_like -// Array of multipliers. -// x2 : array_like, int -// Array of twos exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The result of ``x1 * 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. -// -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. -// -// `ldexp` is useful as the inverse of `frexp`, if used by itself it is -// more clear to simply use the expression ``x1 * 2**x2``. -// -// Examples -// -------- -// >>> np.ldexp(5, np.arange(4)) -// array([ 5., 10., 20., 40.], dtype=float16) -// -// >>> x = np.arange(6) -// >>> np.ldexp(*np.frexp(x)) -// array([ 0., 1., 2., 3., 4., 5.]) -// -//go:linkname Ldexp py.ldexp -func Ldexp(__llgo_va_list ...interface{}) *py.Object -// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Shift the bits of an integer to the left. -// -// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. -// Since the internal representation of numbers is in binary format, this -// operation is equivalent to multiplying `x1` by ``2**x2``. -// -// Parameters -// ---------- -// x1 : array_like of integer type -// Input values. -// x2 : array_like of integer type -// Number of zeros to append to `x1`. Has to be non-negative. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : array of integer type -// Return `x1` with bits shifted `x2` times to the left. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// right_shift : Shift the bits of an integer to the right. -// binary_repr : Return the binary representation of the input number -// as a string. -// -// Examples -// -------- -// >>> np.binary_repr(5) -// '101' -// >>> np.left_shift(5, 2) -// 20 -// >>> np.binary_repr(20) -// '10100' -// -// >>> np.left_shift(5, [1,2,3]) -// array([10, 20, 40]) -// -// Note that the dtype of the second argument may change the dtype of the -// result and can lead to unexpected results in some cases (see -// :ref:`Casting Rules `): -// -// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 -// >>> print(a, type(a)) # Unexpected result due to upcasting -// 510 -// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) -// >>> print(b, type(b)) -// 254 -// -// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on -// ndarrays. -// -// >>> x1 = 5 -// >>> x2 = np.array([1, 2, 3]) -// >>> x1 << x2 -// array([10, 20, 40]) -// -//go:linkname LeftShift py.left_shift -func LeftShift(__llgo_va_list ...interface{}) *py.Object -// less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 < x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// greater, less_equal, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.less([1, 2], [2, 2]) -// array([ True, False]) -// -// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. -// -// >>> a = np.array([1, 2]) -// >>> b = np.array([2, 2]) -// >>> a < b -// array([ True, False]) -// -//go:linkname Less py.less -func Less(__llgo_va_list ...interface{}) *py.Object -// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 <= x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// greater, less, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.less_equal([4, 2, 1], [2, 2, 2]) -// array([False, True, True]) -// -// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on -// ndarrays. -// -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a <= b -// array([False, True, True]) -// -//go:linkname LessEqual py.less_equal -func LessEqual(__llgo_va_list ...interface{}) *py.Object -// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Natural logarithm, element-wise. -// -// The natural logarithm `log` is the inverse of the exponential function, -// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base -// `e`. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The natural logarithm of `x`, element-wise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log10, log2, log1p, emath.log -// -// Notes -// ----- -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `exp(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log` always returns real output. For -// each value that cannot be expressed as a real number or infinity, it -// yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. `log` -// handles the floating-point negative zero as an infinitesimal negative -// number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log([1, np.e, np.e**2, 0]) -// array([ 0., 1., 2., -Inf]) -// -//go:linkname Log py.log -func Log(__llgo_va_list ...interface{}) *py.Object -// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the base 10 logarithm of the input array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The logarithm to the base 10 of `x`, element-wise. NaNs are -// returned where x is negative. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.log10 -// -// Notes -// ----- -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `10**z = x`. The convention is to return the -// `z` whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log10` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log10` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. -// `log10` handles the floating-point negative zero as an infinitesimal -// negative number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log10([1e-15, -3.]) -// array([-15., nan]) -// -//go:linkname Log10 py.log10 -func Log10(__llgo_va_list ...interface{}) *py.Object -// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the natural logarithm of one plus the input array, element-wise. -// -// Calculates ``log(1 + x)``. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Natural logarithm of `1 + x`, element-wise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// expm1 : ``exp(x) - 1``, the inverse of `log1p`. -// -// Notes -// ----- -// For real-valued input, `log1p` is accurate also for `x` so small -// that `1 + x == 1` in floating-point accuracy. -// -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `exp(z) = 1 + x`. The convention is to return -// the `z` whose imaginary part lies in `[-pi, pi]`. -// -// For real-valued input data types, `log1p` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log1p` is a complex analytical function that -// has a branch cut `[-inf, -1]` and is continuous from above on it. -// `log1p` handles the floating-point negative zero as an infinitesimal -// negative number, conforming to the C99 standard. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log1p(1e-99) -// 1e-99 -// >>> np.log(1 + 1e-99) -// 0.0 -// -//go:linkname Log1p py.log1p -func Log1p(__llgo_va_list ...interface{}) *py.Object -// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Base-2 logarithm of `x`. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Base-2 logarithm of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log, log10, log1p, emath.log2 -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `2**z = x`. The convention is to return the `z` -// whose imaginary part lies in `(-pi, pi]`. -// -// For real-valued input data types, `log2` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log2` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` -// handles the floating-point negative zero as an infinitesimal negative -// number, conforming to the C99 standard. -// -// In the cases where the input has a negative real part and a very small -// negative complex part (approaching 0), the result is so close to `-pi` -// that it evaluates to exactly `-pi`. -// -// Examples -// -------- -// >>> x = np.array([0, 1, 2, 2**4]) -// >>> np.log2(x) -// array([-Inf, 0., 1., 4.]) -// -// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) -// >>> np.log2(xi) -// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) -// -//go:linkname Log2 py.log2 -func Log2(__llgo_va_list ...interface{}) *py.Object -// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Logarithm of the sum of exponentiations of the inputs. -// -// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in -// statistics where the calculated probabilities of events may be so small -// as to exceed the range of normal floating point numbers. In such cases -// the logarithm of the calculated probability is stored. This function -// allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Logarithm of ``exp(x1) + exp(x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> prob1 = np.log(1e-50) -// >>> prob2 = np.log(2.5e-50) -// >>> prob12 = np.logaddexp(prob1, prob2) -// >>> prob12 -// -113.87649168120691 -// >>> np.exp(prob12) -// 3.5000000000000057e-50 -// -//go:linkname Logaddexp py.logaddexp -func Logaddexp(__llgo_va_list ...interface{}) *py.Object -// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Logarithm of the sum of exponentiations of the inputs in base-2. -// -// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine -// learning when the calculated probabilities of events may be so small as -// to exceed the range of normal floating point numbers. In such cases -// the base-2 logarithm of the calculated probability can be used instead. -// This function allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Base-2 logarithm of ``2**x1 + 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp: Logarithm of the sum of exponentiations of the inputs. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> prob1 = np.log2(1e-50) -// >>> prob2 = np.log2(2.5e-50) -// >>> prob12 = np.logaddexp2(prob1, prob2) -// >>> prob1, prob2, prob12 -// (-166.09640474436813, -164.77447664948076, -164.28904982231052) -// >>> 2**prob12 -// 3.4999999999999914e-50 -// -//go:linkname Logaddexp2 py.logaddexp2 -func Logaddexp2(__llgo_va_list ...interface{}) *py.Object -// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 AND x2 element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical AND operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_or, logical_not, logical_xor -// bitwise_and -// -// Examples -// -------- -// >>> np.logical_and(True, False) -// False -// >>> np.logical_and([True, False], [False, False]) -// array([False, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_and(x>1, x<4) -// array([False, False, True, True, False]) -// -// -// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on -// boolean ndarrays. -// -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a & b -// array([False, False]) -// -//go:linkname LogicalAnd py.logical_and -func LogicalAnd(__llgo_va_list ...interface{}) *py.Object -// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of NOT x element-wise. -// -// Parameters -// ---------- -// x : array_like -// Logical NOT is applied to the elements of `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool or ndarray of bool -// 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. -// -// See Also -// -------- -// logical_and, logical_or, logical_xor -// -// Examples -// -------- -// >>> np.logical_not(3) -// False -// >>> np.logical_not([True, False, 0, 1]) -// array([False, True, True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_not(x<3) -// array([False, False, False, True, True]) -// -//go:linkname LogicalNot py.logical_not -func LogicalNot(__llgo_va_list ...interface{}) *py.Object -// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 OR x2 element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Logical OR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical OR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and, logical_not, logical_xor -// bitwise_or -// -// Examples -// -------- -// >>> np.logical_or(True, False) -// True -// >>> np.logical_or([True, False], [False, False]) -// array([ True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_or(x < 1, x > 3) -// array([ True, False, False, False, True]) -// -// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on -// boolean ndarrays. -// -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a | b -// array([ True, False]) -// -//go:linkname LogicalOr py.logical_or -func LogicalOr(__llgo_va_list ...interface{}) *py.Object -// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 XOR x2, element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Logical XOR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool or ndarray of bool -// Boolean result of the logical XOR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and, logical_or, logical_not, bitwise_xor -// -// Examples -// -------- -// >>> np.logical_xor(True, False) -// True -// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) -// array([False, True, True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_xor(x < 1, x > 3) -// array([ True, False, False, False, True]) -// -// Simple example showing support of broadcasting -// -// >>> np.logical_xor(0, np.eye(2)) -// array([[ True, False], -// [False, True]]) -// -//go:linkname LogicalXor py.logical_xor -func LogicalXor(__llgo_va_list ...interface{}) *py.Object -// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise maximum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// fmin, amin, nanmin -// -// Notes -// ----- -// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when -// neither x1 nor x2 are nans, but it is faster and does proper -// broadcasting. -// -// Examples -// -------- -// >>> np.maximum([2, 3, 4], [1, 5, 2]) -// array([2, 5, 4]) -// -// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) -// -// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.maximum(np.Inf, 1) -// inf -// -//go:linkname Maximum py.maximum -func Maximum(__llgo_va_list ...interface{}) *py.Object -// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise minimum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. -// -// fmax, amax, nanmax -// -// Notes -// ----- -// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when -// neither x1 nor x2 are NaNs, but it is faster and does proper -// broadcasting. -// -// Examples -// -------- -// >>> np.minimum([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) -// -// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) -// -// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.minimum(-np.Inf, 1) -// -inf -// -//go:linkname Minimum py.minimum -func Minimum(__llgo_va_list ...interface{}) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. -// -// .. warning:: -// -// This should not be confused with: -// -// * Python 3.7's `math.remainder` and C's ``remainder``, which -// computes the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor -// -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. -// -// Examples -// -------- -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) -// -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. -// -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) -// -//go:linkname Mod py.mod -func Mod(__llgo_va_list ...interface{}) *py.Object -// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the fractional and integral parts of an array, element-wise. -// -// The fractional and integral parts are negative if the given number is -// negative. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y1 : ndarray -// Fractional part of `x`. -// This is a scalar if `x` is a scalar. -// y2 : ndarray -// Integral part of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// For integer input the return values are floats. -// -// See Also -// -------- -// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values -// switched, except it always has a positive remainder. -// -// Examples -// -------- -// >>> np.modf([0, 3.5]) -// (array([ 0. , 0.5]), array([ 0., 3.])) -// >>> np.modf(-0.5) -// (-0.5, -0) -// -//go:linkname Modf py.modf -func Modf(__llgo_va_list ...interface{}) *py.Object -// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Multiply arguments element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays to be multiplied. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The product of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to `x1` * `x2` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.multiply(2.0, 4.0) -// 8.0 -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.multiply(x1, x2) -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) -// -// The ``*`` operator can be used as a shorthand for ``np.multiply`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 * x2 -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) -// -//go:linkname Multiply py.multiply -func Multiply(__llgo_va_list ...interface{}) *py.Object -// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Numerical negative, element-wise. -// -// Parameters -// ---------- -// x : array_like or scalar -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// Returned array or scalar: `y = -x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.negative([1.,-1.]) -// array([-1., 1.]) -// -// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> -x1 -// array([-1., 1.]) -// -//go:linkname Negative py.negative -func Negative(__llgo_va_list ...interface{}) *py.Object -// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the next floating-point value after x1 towards x2, element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Values to find the next representable value of. -// x2 : array_like -// The direction where to look for the next representable value of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The next representable values of `x1` in the direction of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> eps = np.finfo(np.float64).eps -// >>> np.nextafter(1, 2) == eps + 1 -// True -// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] -// array([ True, True]) -// -//go:linkname Nextafter py.nextafter -func Nextafter(__llgo_va_list ...interface{}) *py.Object -// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return (x1 != x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// 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. -// -// See Also -// -------- -// equal, greater, greater_equal, less, less_equal -// -// Examples -// -------- -// >>> np.not_equal([1.,2.], [1., 3.]) -// array([False, True]) -// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) -// array([[False, True], -// [False, True]]) -// -// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on -// ndarrays. -// -// >>> a = np.array([1., 2.]) -// >>> b = np.array([1., 3.]) -// >>> a != b -// array([False, True]) -// -//go:linkname NotEqual py.not_equal -func NotEqual(__llgo_va_list ...interface{}) *py.Object -// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Numerical positive, element-wise. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// x : array_like or scalar -// Input array. -// -// Returns -// ------- -// y : ndarray or scalar -// Returned array or scalar: `y = +x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// Equivalent to `x.copy()`, but only defined for types that support -// arithmetic. -// -// Examples -// -------- -// -// >>> x1 = np.array(([1., -1.])) -// >>> np.positive(x1) -// array([ 1., -1.]) -// -// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> +x1 -// array([ 1., -1.]) -// -//go:linkname Positive py.positive -func Positive(__llgo_va_list ...interface{}) *py.Object -// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// First array elements raised to powers from second array, element-wise. -// -// Raise each base in `x1` to the positionally-corresponding power in -// `x2`. `x1` and `x2` must be broadcastable to the same shape. -// -// An integer type raised to a negative integer power will raise a -// ``ValueError``. -// -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). -// -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// float_power : power function that promotes integers to float -// -// Examples -// -------- -// Cube each element in an array. -// -// >>> x1 = np.arange(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.power(x1, 3) -// array([ 0, 1, 8, 27, 64, 125]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.power(x1, x2) -// array([[ 0, 1, 8, 27, 16, 5], -// [ 0, 1, 8, 27, 16, 5]]) -// -// The ``**`` operator can be used as a shorthand for ``np.power`` on -// ndarrays. -// -// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) -// >>> x1 = np.arange(6) -// >>> x1 ** x2 -// array([ 0, 1, 8, 27, 16, 5]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1.0, -4.0]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname Power py.power -func Power(__llgo_va_list ...interface{}) *py.Object -// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Angle in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in degrees. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : Convert angles from degrees to radians. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// rad2deg(x) is ``180 * x / pi``. -// -// Examples -// -------- -// >>> np.rad2deg(np.pi/2) -// 90.0 -// -//go:linkname Rad2deg py.rad2deg -func Rad2deg(__llgo_va_list ...interface{}) *py.Object -// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from degrees to radians. -// -// Parameters -// ---------- -// x : array_like -// Input array in degrees. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding radian values. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : equivalent function -// -// Examples -// -------- -// Convert a degree array to radians -// -// >>> deg = np.arange(12.) * 30. -// >>> np.radians(deg) -// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , -// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, -// 5.23598776, 5.75958653]) -// -// >>> out = np.zeros((deg.shape)) -// >>> ret = np.radians(deg, out) -// >>> ret is out -// True -// -//go:linkname Radians py.radians -func Radians(__llgo_va_list ...interface{}) *py.Object -// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the reciprocal of the argument, element-wise. -// -// Calculates ``1/x``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Return array. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// .. note:: -// This function is not designed to work with integers. -// -// For integer arguments with absolute value larger than 1 the result is -// always zero because of the way Python handles integer division. For -// integer zero the result is an overflow. -// -// Examples -// -------- -// >>> np.reciprocal(2.) -// 0.5 -// >>> np.reciprocal([1, 2., 3.33]) -// array([ 1. , 0.5 , 0.3003003]) -// -//go:linkname Reciprocal py.reciprocal -func Reciprocal(__llgo_va_list ...interface{}) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. -// -// .. warning:: -// -// This should not be confused with: -// -// * Python 3.7's `math.remainder` and C's ``remainder``, which -// computes the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor -// -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. -// -// Examples -// -------- -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) -// -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. -// -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) -// -//go:linkname Remainder py.remainder -func Remainder(__llgo_va_list ...interface{}) *py.Object -// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Shift the bits of an integer to the right. -// -// Bits are shifted to the right `x2`. Because the internal -// representation of numbers is in binary format, this operation is -// equivalent to dividing `x1` by ``2**x2``. -// -// Parameters -// ---------- -// x1 : array_like, int -// Input values. -// x2 : array_like, int -// Number of bits to remove at the right of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray, int -// Return `x1` with bits shifted `x2` times to the right. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// left_shift : Shift the bits of an integer to the left. -// binary_repr : Return the binary representation of the input number -// as a string. -// -// Examples -// -------- -// >>> np.binary_repr(10) -// '1010' -// >>> np.right_shift(10, 1) -// 5 -// >>> np.binary_repr(5) -// '101' -// -// >>> np.right_shift(10, [1,2,3]) -// array([5, 2, 1]) -// -// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on -// ndarrays. -// -// >>> x1 = 10 -// >>> x2 = np.array([1,2,3]) -// >>> x1 >> x2 -// array([5, 2, 1]) -// -//go:linkname RightShift py.right_shift -func RightShift(__llgo_va_list ...interface{}) *py.Object -// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Round elements of the array to the nearest integer. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array is same shape and type as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// fix, ceil, floor, trunc -// -// Notes -// ----- -// For values exactly halfway between rounded decimal values, NumPy -// rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, -// -0.5 and 0.5 round to 0.0, etc. -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.rint(a) -// array([-2., -2., -0., 0., 2., 2., 2.]) -// -//go:linkname Rint py.rint -func Rint(__llgo_va_list ...interface{}) *py.Object -// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns an element-wise indication of the sign of a number. -// -// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan -// is returned for nan inputs. -// -// For complex inputs, the `sign` function returns -// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. -// -// complex(nan, 0) is returned for complex nan inputs. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The sign of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// There is more than one definition of sign in common use for complex -// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` -// which is different from a common alternative, :math:`x/|x|`. -// -// Examples -// -------- -// >>> np.sign([-5., 4.5]) -// array([-1., 1.]) -// >>> np.sign(0) -// 0 -// >>> np.sign(5-2j) -// (1+0j) -// -//go:linkname Sign py.sign -func Sign(__llgo_va_list ...interface{}) *py.Object -// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns element-wise True where signbit is set (less than zero). -// -// Parameters -// ---------- -// x : array_like -// The input value(s). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray of bool -// Output array, or reference to `out` if that was supplied. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.signbit(-1.2) -// True -// >>> np.signbit(np.array([1, -2.3, 2.1])) -// array([False, True, False]) -// -//go:linkname Signbit py.signbit -func Signbit(__llgo_va_list ...interface{}) *py.Object -// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric sine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : array_like -// The sine of each element of x. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// arcsin, sinh, cos -// -// Notes -// ----- -// The sine is one of the fundamental functions of trigonometry (the -// mathematical study of triangles). Consider a circle of radius 1 -// centered on the origin. A ray comes in from the :math:`+x` axis, makes -// an angle at the origin (measured counter-clockwise from that axis), and -// departs from the origin. The :math:`y` coordinate of the outgoing -// ray's intersection with the unit circle is the sine of that angle. It -// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The -// function has zeroes where the angle is a multiple of :math:`\pi`. -// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. -// The numerous properties of the sine and related functions are included -// in any standard trigonometry text. -// -// Examples -// -------- -// Print sine of one angle: -// -// >>> np.sin(np.pi/2.) -// 1.0 -// -// Print sines of an array of angles given in degrees: -// -// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) -// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) -// -// Plot the sine function: -// -// >>> import matplotlib.pylab as plt -// >>> x = np.linspace(-np.pi, np.pi, 201) -// >>> plt.plot(x, np.sin(x)) -// >>> plt.xlabel('Angle [rad]') -// >>> plt.ylabel('sin(x)') -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Sin py.sin -func Sin(__llgo_va_list ...interface{}) *py.Object -// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Hyperbolic sine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or -// ``-1j * np.sin(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding hyperbolic sine values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// -// Examples -// -------- -// >>> np.sinh(0) -// 0.0 -// >>> np.sinh(np.pi*1j/2) -// 1j -// >>> np.sinh(np.pi*1j) # (exact value is 0) -// 1.2246063538223773e-016j -// >>> # Discrepancy due to vagaries of floating point arithmetic. -// -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.sinh([0.1], out1) -// >>> out2 is out1 -// True -// -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Sinh py.sinh -func Sinh(__llgo_va_list ...interface{}) *py.Object -// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the distance between x and the nearest adjacent number. -// -// Parameters -// ---------- -// x : array_like -// Values to find the spacing of. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The spacing of values of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// It can be considered as a generalization of EPS: -// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there -// should not be any representable number between ``x + spacing(x)`` and -// x for any finite x. -// -// Spacing of +- inf and NaN is NaN. -// -// Examples -// -------- -// >>> np.spacing(1) == np.finfo(np.float64).eps -// True -// -//go:linkname Spacing py.spacing -func Spacing(__llgo_va_list ...interface{}) *py.Object -// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the non-negative square-root of an array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// The values whose square-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the positive -// square-root of each element in `x`. If any element in `x` is -// complex, a complex array is returned (and the square-roots of -// negative reals are calculated). If all of the elements in `x` -// are real, so is `y`, with negative elements returning ``nan``. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.sqrt -// A version which returns complex numbers when given negative reals. -// Note that 0.0 and -0.0 are handled differently for complex inputs. -// -// Notes -// ----- -// *sqrt* has--consistent with common convention--as its branch cut the -// real "interval" [`-inf`, 0), and is continuous from above on it. -// A branch cut is a curve in the complex plane across which a given -// complex function fails to be continuous. -// -// Examples -// -------- -// >>> np.sqrt([1,4,9]) -// array([ 1., 2., 3.]) -// -// >>> np.sqrt([4, -1, -3+4J]) -// array([ 2.+0.j, 0.+1.j, 1.+2.j]) -// -// >>> np.sqrt([4, -1, np.inf]) -// array([ 2., nan, inf]) -// -//go:linkname Sqrt py.sqrt -func Sqrt(__llgo_va_list ...interface{}) *py.Object -// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the element-wise square of the input. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise `x*x`, of the same shape and dtype as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// numpy.linalg.matrix_power -// sqrt -// power -// -// Examples -// -------- -// >>> np.square([-1j, 1]) -// array([-1.-0.j, 1.+0.j]) -// -//go:linkname Square py.square -func Square(__llgo_va_list ...interface{}) *py.Object -// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Subtract arguments, element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays to be subtracted from each other. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The difference of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to ``x1 - x2`` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.subtract(1.0, 4.0) -// -3.0 -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.subtract(x1, x2) -// array([[ 0., 0., 0.], -// [ 3., 3., 3.], -// [ 6., 6., 6.]]) -// -// The ``-`` operator can be used as a shorthand for ``np.subtract`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 - x2 -// array([[0., 0., 0.], -// [3., 3., 3.], -// [6., 6., 6.]]) -// -//go:linkname Subtract py.subtract -func Subtract(__llgo_va_list ...interface{}) *py.Object -// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute tangent element-wise. -// -// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding tangent values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. -// -// Examples -// -------- -// >>> from math import pi -// >>> np.tan(np.array([-pi,pi/2,pi])) -// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) -// >>> -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Tan py.tan -func Tan(__llgo_va_list ...interface{}) *py.Object -// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute hyperbolic tangent element-wise. -// -// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding hyperbolic tangent values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// https://personal.math.ubc.ca/~cbm/aands/page_83.htm -// -// .. [2] Wikipedia, "Hyperbolic function", -// https://en.wikipedia.org/wiki/Hyperbolic_function -// -// Examples -// -------- -// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) -// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) -// -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.tanh([0.1], out1) -// >>> out2 is out1 -// True -// -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Tanh py.tanh -func Tanh(__llgo_va_list ...interface{}) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Divide arguments element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. -// -// Examples -// -------- -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.divide(x1, x2) -// array([[nan, 1. , 1. ], -// [inf, 4. , 2.5], -// [inf, 7. , 4. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) -// -//go:linkname TrueDivide py.true_divide -func TrueDivide(__llgo_va_list ...interface{}) *py.Object -// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truncated value of the input, element-wise. -// -// The truncated value of the scalar `x` is the nearest integer `i` which -// is closer to zero than `x` is. In short, the fractional part of the -// signed number `x` is discarded. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The truncated value of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ceil, floor, rint, fix -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.trunc(a) -// array([-1., -1., -0., 0., 1., 1., 2.]) -// -//go:linkname Trunc py.trunc -func Trunc(__llgo_va_list ...interface{}) *py.Object -// -// Return the scalar dtype or NumPy equivalent of Python type of an object. -// -// Parameters -// ---------- -// rep : any -// The object of which the type is returned. -// default : any, optional -// If given, this is returned for objects whose types can not be -// determined. If not given, None is returned for those objects. -// -// Returns -// ------- -// dtype : dtype or Python type -// The data type of `rep`. -// -// See Also -// -------- -// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype -// -// Examples -// -------- -// >>> np.obj2sctype(np.int32) -// -// >>> np.obj2sctype(np.array([1., 2.])) -// -// >>> np.obj2sctype(np.array([1.j])) -// -// -// >>> np.obj2sctype(dict) -// -// >>> np.obj2sctype('string') -// -// >>> np.obj2sctype(1, default=list) -// -// -// -// -//go:linkname Obj2sctype py.obj2sctype -func Obj2sctype(rep *py.Object, default_ *py.Object) *py.Object -// -// Return the string representation of a scalar dtype. -// -// Parameters -// ---------- -// sctype : scalar dtype or object -// If a scalar dtype, the corresponding string character is -// returned. If an object, `sctype2char` tries to infer its scalar type -// and then return the corresponding string character. -// -// Returns -// ------- -// typechar : str -// The string character corresponding to the scalar type. -// -// Raises -// ------ -// ValueError -// If `sctype` is an object for which the type can not be inferred. -// -// See Also -// -------- -// obj2sctype, issctype, issubsctype, mintypecode -// -// Examples -// -------- -// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: -// ... print(np.sctype2char(sctype)) -// l # may vary -// d -// D -// S -// O -// -// >>> x = np.array([1., 2-1.j]) -// >>> np.sctype2char(x) -// 'D' -// >>> np.sctype2char(list) -// 'O' -// -// -// -//go:linkname Sctype2char py.sctype2char -func Sctype2char(sctype *py.Object) *py.Object -// -// Return the scalar type of highest precision of the same kind as the input. -// -// Parameters -// ---------- -// t : dtype or dtype specifier -// The input data type. This can be a `dtype` object or an object that -// is convertible to a `dtype`. -// -// Returns -// ------- -// out : dtype -// The highest precision data type of the same kind (`dtype.kind`) as `t`. -// -// See Also -// -------- -// obj2sctype, mintypecode, sctype2char -// dtype -// -// Examples -// -------- -// >>> np.maximum_sctype(int) -// -// >>> np.maximum_sctype(np.uint8) -// -// >>> np.maximum_sctype(complex) -// # may vary -// -// >>> np.maximum_sctype(str) -// -// -// >>> np.maximum_sctype('i2') -// -// >>> np.maximum_sctype('f4') -// # may vary -// -// -// -//go:linkname MaximumSctype py.maximum_sctype -func MaximumSctype(t *py.Object) *py.Object -// -// Determines whether the given object represents a scalar data-type. -// -// Parameters -// ---------- -// rep : any -// If `rep` is an instance of a scalar dtype, True is returned. If not, -// False is returned. -// -// Returns -// ------- -// out : bool -// Boolean result of check whether `rep` is a scalar dtype. -// -// See Also -// -------- -// issubsctype, issubdtype, obj2sctype, sctype2char -// -// Examples -// -------- -// >>> np.issctype(np.int32) -// True -// >>> np.issctype(list) -// False -// >>> np.issctype(1.1) -// False -// -// Strings are also a scalar type: -// -// >>> np.issctype(np.dtype('str')) -// True -// -// -// -//go:linkname Issctype py.issctype -func Issctype(rep *py.Object) *py.Object -// -// Determine common type following standard coercion rules. -// -// .. deprecated:: NumPy 1.25 -// -// This function is deprecated, use `numpy.promote_types` or -// `numpy.result_type` instead. To achieve semantics for the -// `scalar_types` argument, use `numpy.result_type` and pass the Python -// values `0`, `0.0`, or `0j`. -// This will give the same results in almost all cases. -// More information and rare exception can be found in the -// `NumPy 1.25 release notes `_. -// -// Parameters -// ---------- -// array_types : sequence -// A list of dtypes or dtype convertible objects representing arrays. -// scalar_types : sequence -// A list of dtypes or dtype convertible objects representing scalars. -// -// Returns -// ------- -// datatype : dtype -// The common data type, which is the maximum of `array_types` ignoring -// `scalar_types`, unless the maximum of `scalar_types` is of a -// different kind (`dtype.kind`). If the kind is not understood, then -// None is returned. -// -// See Also -// -------- -// dtype, common_type, can_cast, mintypecode -// -// Examples -// -------- -// >>> np.find_common_type([], [np.int64, np.float32, complex]) -// dtype('complex128') -// >>> np.find_common_type([np.int64, np.float32], []) -// dtype('float64') -// -// The standard casting rules ensure that a scalar cannot up-cast an -// array unless the scalar is of a fundamentally different kind of data -// (i.e. under a different hierarchy in the data type hierarchy) then -// the array: -// -// >>> np.find_common_type([np.float32], [np.int64, np.float64]) -// dtype('float32') -// -// Complex is of a different type, so it up-casts the float in the -// `array_types` argument: -// -// >>> np.find_common_type([np.float32], [complex]) -// dtype('complex128') -// -// Type specifier strings are convertible to dtypes and can therefore -// be used instead of dtypes: -// -// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) -// dtype('complex128') -// -// -// -//go:linkname FindCommonType py.find_common_type -func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object -// -// Returns True if first argument is a typecode lower/equal in type hierarchy. -// -// This is like the builtin :func:`issubclass`, but for `dtype`\ s. -// -// Parameters -// ---------- -// arg1, arg2 : dtype_like -// `dtype` or object coercible to one -// -// Returns -// ------- -// out : bool -// -// See Also -// -------- -// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. -// issubsctype, issubclass_ -// -// Examples -// -------- -// `issubdtype` can be used to check the type of arrays: -// -// >>> ints = np.array([1, 2, 3], dtype=np.int32) -// >>> np.issubdtype(ints.dtype, np.integer) -// True -// >>> np.issubdtype(ints.dtype, np.floating) -// False -// -// >>> floats = np.array([1, 2, 3], dtype=np.float32) -// >>> np.issubdtype(floats.dtype, np.integer) -// False -// >>> np.issubdtype(floats.dtype, np.floating) -// True -// -// Similar types of different sizes are not subdtypes of each other: -// -// >>> np.issubdtype(np.float64, np.float32) -// False -// >>> np.issubdtype(np.float32, np.float64) -// False -// -// but both are subtypes of `floating`: -// -// >>> np.issubdtype(np.float64, np.floating) -// True -// >>> np.issubdtype(np.float32, np.floating) -// True -// -// For convenience, dtype-like objects are allowed too: -// -// >>> np.issubdtype('S1', np.string_) -// True -// >>> np.issubdtype('i4', np.signedinteger) -// True -// -// -// -//go:linkname Issubdtype py.issubdtype -func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Set a Python function to be used when pretty printing arrays. -// -// Parameters -// ---------- -// f : function or None -// Function to be used to pretty print arrays. The function should expect -// a single array argument and return a string of the representation of -// the array. If None, the function is reset to the default NumPy function -// to print arrays. -// repr : bool, optional -// If True (default), the function for pretty printing (``__repr__``) -// is set, if False the function that returns the default string -// representation (``__str__``) is set. -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// Examples -// -------- -// >>> def pprint(arr): -// ... return 'HA! - What are you going to do now?' -// ... -// >>> np.set_string_function(pprint) -// >>> a = np.arange(10) -// >>> a -// HA! - What are you going to do now? -// >>> _ = a -// >>> # [0 1 2 3 4 5 6 7 8 9] -// -// We can reset the function to the default: -// -// >>> np.set_string_function(None) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// -// `repr` affects either pretty printing or normal string representation. -// Note that ``__repr__`` is still affected by setting ``__str__`` -// because the width of each array element in the returned string becomes -// equal to the length of the result of ``__str__()``. -// -// >>> x = np.arange(4) -// >>> np.set_string_function(lambda x:'random', repr=False) -// >>> x.__str__() -// 'random' -// >>> x.__repr__() -// 'array([0, 1, 2, 3])' -// -// -// -//go:linkname SetStringFunction py.set_string_function -func SetStringFunction(f *py.Object, repr *py.Object) *py.Object -// -// Set printing options. -// -// These options determine the way floating point numbers, arrays and -// other NumPy objects are displayed. -// -// Parameters -// ---------- -// precision : int or None, optional -// Number of digits of precision for floating point output (default 8). -// May be None if `floatmode` is not `fixed`, to print as many digits as -// necessary to uniquely specify the value. -// threshold : int, optional -// Total number of array elements which trigger summarization -// rather than full repr (default 1000). -// To always use the full repr without summarization, pass `sys.maxsize`. -// edgeitems : int, optional -// Number of array items in summary at beginning and end of -// each dimension (default 3). -// linewidth : int, optional -// The number of characters per line for the purpose of inserting -// line breaks (default 75). -// suppress : bool, optional -// If True, always print floating point numbers using fixed point -// notation, in which case numbers equal to zero in the current precision -// will print as zero. If False, then scientific notation is used when -// absolute value of the smallest number is < 1e-4 or the ratio of the -// maximum absolute value to the minimum is > 1e3. The default is False. -// nanstr : str, optional -// String representation of floating point not-a-number (default nan). -// infstr : str, optional -// String representation of floating point infinity (default inf). -// sign : string, either '-', '+', or ' ', optional -// Controls printing of the sign of floating-point types. If '+', always -// print the sign of positive values. If ' ', always prints a space -// (whitespace character) in the sign position of positive values. If -// '-', omit the sign character of positive values. (default '-') -// formatter : dict of callables, optional -// If not None, the keys should indicate the type(s) that the respective -// formatting function applies to. Callables should return a string. -// Types that are not specified (by their corresponding keys) are handled -// by the default formatters. Individual types for which a formatter -// can be set are: -// -// - 'bool' -// - 'int' -// - 'timedelta' : a `numpy.timedelta64` -// - 'datetime' : a `numpy.datetime64` -// - 'float' -// - 'longfloat' : 128-bit floats -// - 'complexfloat' -// - 'longcomplexfloat' : composed of two 128-bit floats -// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` -// - 'object' : `np.object_` arrays -// -// Other keys that can be used to set a group of types at once are: -// -// - 'all' : sets all types -// - 'int_kind' : sets 'int' -// - 'float_kind' : sets 'float' and 'longfloat' -// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' -// - 'str_kind' : sets 'numpystr' -// floatmode : str, optional -// Controls the interpretation of the `precision` option for -// floating-point types. Can take the following values -// (default maxprec_equal): -// -// * 'fixed': Always print exactly `precision` fractional digits, -// even if this would print more or fewer digits than -// necessary to specify the value uniquely. -// * 'unique': Print the minimum number of fractional digits necessary -// to represent each value uniquely. Different elements may -// have a different number of digits. The value of the -// `precision` option is ignored. -// * 'maxprec': Print at most `precision` fractional digits, but if -// an element can be uniquely represented with fewer digits -// only print it with that many. -// * 'maxprec_equal': Print at most `precision` fractional digits, -// but if every element in the array can be uniquely -// represented with an equal number of fewer digits, use that -// many digits for all elements. -// legacy : string or `False`, optional -// If set to the string `'1.13'` enables 1.13 legacy printing mode. This -// approximates numpy 1.13 print output by including a space in the sign -// position of floats and different behavior for 0d arrays. This also -// enables 1.21 legacy printing mode (described below). -// -// If set to the string `'1.21'` enables 1.21 legacy printing mode. This -// approximates numpy 1.21 print output of complex structured dtypes -// by not inserting spaces after commas that separate fields and after -// colons. -// -// If set to `False`, disables legacy mode. -// -// Unrecognized strings will be ignored with a warning for forward -// compatibility. -// -// .. versionadded:: 1.14.0 -// .. versionchanged:: 1.22.0 -// -// See Also -// -------- -// get_printoptions, printoptions, set_string_function, array2string -// -// Notes -// ----- -// `formatter` is always reset with a call to `set_printoptions`. -// -// Use `printoptions` as a context manager to set the values temporarily. -// -// Examples -// -------- -// Floating point precision can be set: -// -// >>> np.set_printoptions(precision=4) -// >>> np.array([1.123456789]) -// [1.1235] -// -// Long arrays can be summarised: -// -// >>> np.set_printoptions(threshold=5) -// >>> np.arange(10) -// array([0, 1, 2, ..., 7, 8, 9]) -// -// Small results can be suppressed: -// -// >>> eps = np.finfo(float).eps -// >>> x = np.arange(4.) -// >>> x**2 - (x + eps)**2 -// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) -// >>> np.set_printoptions(suppress=True) -// >>> x**2 - (x + eps)**2 -// array([-0., -0., 0., 0.]) -// -// A custom formatter can be used to display array elements as desired: -// -// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) -// >>> x = np.arange(3) -// >>> x -// array([int: 0, int: -1, int: -2]) -// >>> np.set_printoptions() # formatter gets reset -// >>> x -// array([0, 1, 2]) -// -// To put back the default options, you can use: -// -// >>> np.set_printoptions(edgeitems=3, infstr='inf', -// ... linewidth=75, nanstr='nan', precision=8, -// ... suppress=False, threshold=1000, formatter=None) -// -// Also to temporarily override options, use `printoptions` as a context manager: -// -// >>> with np.printoptions(precision=2, suppress=True, threshold=5): -// ... np.linspace(0, 10, 10) -// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) -// -// -// -//go:linkname SetPrintoptions py.set_printoptions -func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object -// -// Return the current print options. -// -// Returns -// ------- -// print_opts : dict -// Dictionary of current print options with keys -// -// - precision : int -// - threshold : int -// - edgeitems : int -// - linewidth : int -// - suppress : bool -// - nanstr : str -// - infstr : str -// - formatter : dict of callables -// - sign : str -// -// For a full description of these options, see `set_printoptions`. -// -// See Also -// -------- -// set_printoptions, printoptions, set_string_function -// -// -// -//go:linkname GetPrintoptions py.get_printoptions -func GetPrintoptions() *py.Object -// Context manager for setting print options. -// -// Set print options for the scope of the `with` block, and restore the old -// options at the end. See `set_printoptions` for the full description of -// available options. -// -// Examples -// -------- -// -// >>> from numpy.testing import assert_equal -// >>> with np.printoptions(precision=2): -// ... np.array([2.0]) / 3 -// array([0.67]) -// -// The `as`-clause of the `with`-statement gives the current print options: -// -// >>> with np.printoptions(precision=2) as opts: -// ... assert_equal(opts, np.get_printoptions()) -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// -// -//go:linkname Printoptions py.printoptions -func Printoptions(__llgo_va_list ...interface{}) *py.Object -// -// Format a floating-point scalar as a decimal string in positional notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed, or if `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// fractional : boolean, optional -// If `True`, the cutoffs of `precision` and `min_digits` refer to the -// total number of digits after the decimal point, including leading -// zeros. -// If `False`, `precision` and `min_digits` refer to the total number of -// significant digits, before or after the decimal point, ignoring leading -// zeros. -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// pad_right : non-negative integer, optional -// Pad the right side of the string with whitespace until at least that -// many characters are to the right of the decimal point. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. Only has an effect if `unique=True` -// in which case additional digits past those necessary to uniquely -// identify the value may be printed, rounding the last additional digit. -// -// -- versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_scientific -// -// Examples -// -------- -// >>> np.format_float_positional(np.float32(np.pi)) -// '3.1415927' -// >>> np.format_float_positional(np.float16(np.pi)) -// '3.14' -// >>> np.format_float_positional(np.float16(0.3)) -// '0.3' -// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) -// '0.3000488281' -// -// -//go:linkname FormatFloatPositional py.format_float_positional -func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object -// -// Format a floating-point scalar as a decimal string in scientific notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed. If `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// exp_digits : non-negative integer, optional -// Pad the exponent with zeros until it contains at least this many digits. -// If omitted, the exponent will be at least 2 digits. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. This only has an effect for -// `unique=True`. In that case more digits than necessary to uniquely -// identify the value may be printed and rounded unbiased. -// -// -- versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_positional -// -// Examples -// -------- -// >>> np.format_float_scientific(np.float32(np.pi)) -// '3.1415927e+00' -// >>> s = np.float32(1.23e24) -// >>> np.format_float_scientific(s, unique=False, precision=15) -// '1.230000071797338e+24' -// >>> np.format_float_scientific(s, exp_digits=4) -// '1.23e+0024' -// -// -//go:linkname FormatFloatScientific py.format_float_scientific -func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object -// -// Return an ndarray of the provided type that satisfies requirements. -// -// This function is useful to be sure that an array with the correct flags -// is returned for passing to compiled code (perhaps through ctypes). -// -// Parameters -// ---------- -// a : array_like -// The object to be converted to a type-and-requirement-satisfying array. -// dtype : data-type -// The required data-type. If None preserve the current dtype. If your -// application requires the data to be in native byteorder, include -// a byteorder specification as a part of the dtype specification. -// requirements : str or sequence of str -// The requirements list can be any of the following -// -// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array -// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array -// * 'ALIGNED' ('A') - ensure a data-type aligned array -// * 'WRITEABLE' ('W') - ensure a writable array -// * 'OWNDATA' ('O') - ensure an array that owns its own data -// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array with specified requirements and type if given. -// -// See Also -// -------- -// asarray : Convert input to an ndarray. -// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// ndarray.flags : Information about the memory layout of the array. -// -// Notes -// ----- -// The returned array will be guaranteed to have the listed requirements -// by making a copy if needed. -// -// Examples -// -------- -// >>> x = np.arange(6).reshape(2,3) -// >>> x.flags -// C_CONTIGUOUS : True -// F_CONTIGUOUS : False -// OWNDATA : False -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False -// -// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) -// >>> y.flags -// C_CONTIGUOUS : False -// F_CONTIGUOUS : True -// OWNDATA : True -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False -// -// -// -//go:linkname Require py.require -func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object -// -// Set how floating-point errors are handled. -// -// Note that operations on integer scalar types (such as `int16`) are -// handled like floating point, and are affected by these settings. -// -// Parameters -// ---------- -// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Set treatment for all types of floating-point errors at once: -// -// - ignore: Take no action when the exception occurs. -// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). -// - raise: Raise a `FloatingPointError`. -// - call: Call a function specified using the `seterrcall` function. -// - print: Print a warning directly to ``stdout``. -// - log: Record error in a Log object specified by `seterrcall`. -// -// The default is not to change the current behavior. -// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for division by zero. -// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point overflow. -// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point underflow. -// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for invalid floating-point operation. -// -// Returns -// ------- -// old_settings : dict -// Dictionary containing the old settings. -// -// See also -// -------- -// seterrcall : Set a callback function for the 'call' mode. -// geterr, geterrcall, errstate -// -// Notes -// ----- -// The floating-point exceptions are defined in the IEEE 754 standard [1]_: -// -// - Division by zero: infinite result obtained from finite numbers. -// - Overflow: result too large to be expressed. -// - Underflow: result so close to zero that some precision -// was lost. -// - Invalid operation: result is not an expressible number, typically -// indicates that a NaN was produced. -// -// .. [1] https://en.wikipedia.org/wiki/IEEE_754 -// -// Examples -// -------- -// >>> old_settings = np.seterr(all='ignore') #seterr to known value -// >>> np.seterr(over='raise') -// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} -// >>> np.seterr(**old_settings) # reset to default -// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} -// -// >>> np.int16(32000) * np.int16(3) -// 30464 -// >>> old_settings = np.seterr(all='warn', over='raise') -// >>> np.int16(32000) * np.int16(3) -// Traceback (most recent call last): -// File "", line 1, in -// FloatingPointError: overflow encountered in scalar multiply -// -// >>> old_settings = np.seterr(all='print') -// >>> np.geterr() -// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} -// >>> np.int16(32000) * np.int16(3) -// 30464 -// -// -// -//go:linkname Seterr py.seterr -func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object -// -// Get the current way of handling floating-point errors. -// -// Returns -// ------- -// res : dict -// A dictionary with keys "divide", "over", "under", and "invalid", -// whose values are from the strings "ignore", "print", "log", "warn", -// "raise", and "call". The keys represent possible floating-point -// exceptions, and the values define how these exceptions are handled. -// -// See Also -// -------- -// geterrcall, seterr, seterrcall -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterr() -// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) -// array([nan, 1., 1.]) -// -// >>> oldsettings = np.seterr(all='warn', over='raise') -// >>> np.geterr() -// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) -// array([nan, 1., 1.]) -// -// -// -//go:linkname Geterr py.geterr -func Geterr() *py.Object -// -// Set the size of the buffer used in ufuncs. -// -// Parameters -// ---------- -// size : int -// Size of buffer. -// -// -// -//go:linkname Setbufsize py.setbufsize -func Setbufsize(size *py.Object) *py.Object -// -// Return the size of the buffer used in ufuncs. -// -// Returns -// ------- -// getbufsize : int -// Size of ufunc buffer in bytes. -// -// -// -//go:linkname Getbufsize py.getbufsize -func Getbufsize() *py.Object -// -// Set the floating-point error callback function or log object. -// -// There are two ways to capture floating-point error messages. The first -// is to set the error-handler to 'call', using `seterr`. Then, set -// the function to call using this function. -// -// The second is to set the error-handler to 'log', using `seterr`. -// Floating-point errors then trigger a call to the 'write' method of -// the provided object. -// -// Parameters -// ---------- -// func : callable f(err, flag) or object with write method -// Function to call upon floating-point errors ('call'-mode) or -// object whose 'write' method is used to log such message ('log'-mode). -// -// The call function takes two arguments. The first is a string describing -// the type of error (such as "divide by zero", "overflow", "underflow", -// or "invalid value"), and the second is the status flag. The flag is a -// byte, whose four least-significant bits indicate the type of error, one -// of "divide", "over", "under", "invalid":: -// -// [0 0 0 0 divide over under invalid] -// -// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. -// -// If an object is provided, its write method should take one argument, -// a string. -// -// Returns -// ------- -// h : callable, log instance or None -// The old error handler. -// -// See Also -// -------- -// seterr, geterr, geterrcall -// -// Examples -// -------- -// Callback upon error: -// -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// ... -// -// >>> saved_handler = np.seterrcall(err_handler) -// >>> save_err = np.seterr(all='call') -// -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> np.seterrcall(saved_handler) -// -// >>> np.seterr(**save_err) -// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} -// -// Log error message: -// -// >>> class Log: -// ... def write(self, msg): -// ... print("LOG: %s" % msg) -// ... -// -// >>> log = Log() -// >>> saved_handler = np.seterrcall(log) -// >>> save_err = np.seterr(all='log') -// -// >>> np.array([1, 2, 3]) / 0.0 -// LOG: Warning: divide by zero encountered in divide -// array([inf, inf, inf]) -// -// >>> np.seterrcall(saved_handler) -// -// >>> np.seterr(**save_err) -// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} -// -// -// -//go:linkname Seterrcall py.seterrcall -func Seterrcall(func_ *py.Object) *py.Object -// -// Return the current callback function used on floating-point errors. -// -// When the error handling for a floating-point error (one of "divide", -// "over", "under", or "invalid") is set to 'call' or 'log', the function -// that is called or the log instance that is written to is returned by -// `geterrcall`. This function or log instance has been set with -// `seterrcall`. -// -// Returns -// ------- -// errobj : callable, log instance or None -// The current error handler. If no handler was set through `seterrcall`, -// ``None`` is returned. -// -// See Also -// -------- -// seterrcall, seterr, geterr -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterrcall() # we did not yet set a handler, returns None -// -// >>> oldsettings = np.seterr(all='call') -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// >>> oldhandler = np.seterrcall(err_handler) -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> cur_handler = np.geterrcall() -// >>> cur_handler is err_handler -// True -// -// -// -//go:linkname Geterrcall py.geterrcall -func Geterrcall() *py.Object -// -// Return a description for the given data type code. -// -// Parameters -// ---------- -// char : str -// Data type code. -// -// Returns -// ------- -// out : str -// Description of the input data type code. -// -// See Also -// -------- -// dtype, typecodes -// -// Examples -// -------- -// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', -// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] -// >>> for typechar in typechars: -// ... print(typechar, ' : ', np.typename(typechar)) -// ... -// S1 : character -// ? : bool -// B : unsigned char -// D : complex double precision -// G : complex long double precision -// F : complex single precision -// I : unsigned integer -// H : unsigned short -// L : unsigned long integer -// O : object -// Q : unsigned long long integer -// S : string -// U : unicode -// V : void -// b : signed char -// d : double precision -// g : long precision -// f : single precision -// i : integer -// h : short -// l : long integer -// q : long long integer -// -// -// -//go:linkname Typename py.typename -func Typename(char *py.Object) *py.Object -// -// Return the character for the minimum-size type to which given types can -// be safely cast. -// -// The returned type character must represent the smallest size dtype such -// that an array of the returned type can handle the data from an array of -// all types in `typechars` (or if `typechars` is an array, then its -// dtype.char). -// -// Parameters -// ---------- -// typechars : list of str or array_like -// If a list of strings, each string should represent a dtype. -// If array_like, the character representation of the array dtype is used. -// typeset : str or list of str, optional -// The set of characters that the returned character is chosen from. -// The default set is 'GDFgdf'. -// default : str, optional -// The default character, this is returned if none of the characters in -// `typechars` matches a character in `typeset`. -// -// Returns -// ------- -// typechar : str -// The character representing the minimum-size type that was found. -// -// See Also -// -------- -// dtype, sctype2char, maximum_sctype -// -// Examples -// -------- -// >>> np.mintypecode(['d', 'f', 'S']) -// 'd' -// >>> x = np.array([1.1, 2-3.j]) -// >>> np.mintypecode(x) -// 'D' -// -// >>> np.mintypecode('abceh', default='G') -// 'G' -// -// -// -//go:linkname Mintypecode py.mintypecode -func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *py.Object) *py.Object -// -// Return the indices to access the main diagonal of an array. -// -// This returns a tuple of indices that can be used to access the main -// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape -// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for -// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` -// for ``i = [0..n-1]``. -// -// Parameters -// ---------- -// n : int -// The size, along each dimension, of the arrays for which the returned -// indices can be used. -// -// ndim : int, optional -// The number of dimensions. -// -// See Also -// -------- -// diag_indices_from -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Create a set of indices to access the diagonal of a (4, 4) array: -// -// >>> di = np.diag_indices(4) -// >>> di -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// >>> a[di] = 100 -// >>> a -// array([[100, 1, 2, 3], -// [ 4, 100, 6, 7], -// [ 8, 9, 100, 11], -// [ 12, 13, 14, 100]]) -// -// Now, we create indices to manipulate a 3-D array: -// -// >>> d3 = np.diag_indices(2, 3) -// >>> d3 -// (array([0, 1]), array([0, 1]), array([0, 1])) -// -// And use it to set the diagonal of an array of zeros to 1: -// -// >>> a = np.zeros((2, 2, 2), dtype=int) -// >>> a[d3] = 1 -// >>> a -// array([[[1, 0], -// [0, 0]], -// [[0, 0], -// [0, 1]]]) -// -// -// -//go:linkname DiagIndices py.diag_indices -func DiagIndices(n *py.Object, ndim *py.Object) *py.Object -// -// Check whether or not an object can be iterated over. -// -// Parameters -// ---------- -// y : object -// Input object. -// -// Returns -// ------- -// b : bool -// Return ``True`` if the object has an iterator method or is a -// sequence and ``False`` otherwise. -// -// -// Examples -// -------- -// >>> np.iterable([1, 2, 3]) -// True -// >>> np.iterable(2) -// False -// -// Notes -// ----- -// In most cases, the results of ``np.iterable(obj)`` are consistent with -// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is -// the treatment of 0-dimensional arrays:: -// -// >>> from collections.abc import Iterable -// >>> a = np.array(1.0) # 0-dimensional numpy array -// >>> isinstance(a, Iterable) -// True -// >>> np.iterable(a) -// False -// -// -// -//go:linkname Iterable py.iterable -func Iterable(y *py.Object) *py.Object -// -// Display a message on a device. -// -// Parameters -// ---------- -// mesg : str -// Message to display. -// device : object -// Device to write message. If None, defaults to ``sys.stdout`` which is -// very similar to ``print``. `device` needs to have ``write()`` and -// ``flush()`` methods. -// linefeed : bool, optional -// Option whether to print a line feed or not. Defaults to True. -// -// Raises -// ------ -// AttributeError -// If `device` does not have a ``write()`` or ``flush()`` method. -// -// Examples -// -------- -// Besides ``sys.stdout``, a file-like object can also be used as it has -// both required methods: -// -// >>> from io import StringIO -// >>> buf = StringIO() -// >>> np.disp(u'"Display" in a file', device=buf) -// >>> buf.getvalue() -// '"Display" in a file\n' -// -// -// -//go:linkname Disp py.disp -func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object -// Convert the input to an array, checking for NaNs or Infs. -// -// Parameters -// ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes lists, lists of tuples, tuples, tuples of tuples, tuples -// of lists and ndarrays. Success requires no NaNs or Infs. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'C'. -// -// Returns -// ------- -// out : ndarray -// Array interpretation of `a`. No copy is performed if the input -// is already an ndarray. If `a` is a subclass of ndarray, a base -// class ndarray is returned. -// -// Raises -// ------ -// ValueError -// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). -// -// See Also -// -------- -// asarray : Create and array. -// asanyarray : Similar function which passes through subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfarray : Convert input to a floating point ndarray. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. -// -// Examples -// -------- -// Convert a list into an array. If all elements are finite -// ``asarray_chkfinite`` is identical to ``asarray``. -// -// >>> a = [1, 2] -// >>> np.asarray_chkfinite(a, dtype=float) -// array([1., 2.]) -// -// Raises ValueError if array_like contains Nans or Infs. -// -// >>> a = [1, 2, np.inf] -// >>> try: -// ... np.asarray_chkfinite(a) -// ... except ValueError: -// ... print('ValueError') -// ... -// ValueError -// -// -// -//go:linkname AsarrayChkfinite py.asarray_chkfinite -func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Return the Hamming window. -// -// The Hamming window is a taper formed by using a weighted cosine. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, blackman, hanning, kaiser -// -// Notes -// ----- -// The Hamming window is defined as -// -// .. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right) -// \qquad 0 \leq n \leq M-1 -// -// The Hamming was named for R. W. Hamming, an associate of J. W. Tukey -// and is described in Blackman and Tukey. It was recommended for -// smoothing the truncated autocovariance function in the time domain. -// Most references to the Hamming window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 109-110. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> np.hamming(12) -// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary -// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, -// 0.15302337, 0.08 ]) -// -// Plot the window and the frequency response: -// -// >>> import matplotlib.pyplot as plt -// >>> from numpy.fft import fft, fftshift -// >>> window = np.hamming(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Hamming window") -// Text(0.5, 1.0, 'Hamming window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> response = 20 * np.log10(mag) -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Hamming window") -// Text(0.5, 1.0, 'Frequency response of Hamming window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// ... -// >>> plt.show() -// -// -// -//go:linkname Hamming py.hamming -func Hamming(M *py.Object) *py.Object -// -// Return the Hanning window. -// -// The Hanning window is a taper formed by using a weighted cosine. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray, shape(M,) -// The window, with the maximum value normalized to one (the value -// one appears only if `M` is odd). -// -// See Also -// -------- -// bartlett, blackman, hamming, kaiser -// -// Notes -// ----- -// The Hanning window is defined as -// -// .. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right) -// \qquad 0 \leq n \leq M-1 -// -// The Hanning was named for Julius von Hann, an Austrian meteorologist. -// It is also known as the Cosine Bell. Some authors prefer that it be -// called a Hann window, to help avoid confusion with the very similar -// Hamming window. -// -// Most references to the Hanning window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 106-108. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> np.hanning(12) -// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, -// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, -// 0.07937323, 0. ]) -// -// Plot the window and its frequency response: -// -// >>> import matplotlib.pyplot as plt -// >>> from numpy.fft import fft, fftshift -// >>> window = np.hanning(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Hann window") -// Text(0.5, 1.0, 'Hann window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of the Hann window") -// Text(0.5, 1.0, 'Frequency response of the Hann window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// ... -// >>> plt.show() -// -// -// -//go:linkname Hanning py.hanning -func Hanning(M *py.Object) *py.Object -// -// Return the Bartlett window. -// -// The Bartlett window is very similar to a triangular window, except -// that the end points are at zero. It is often used in signal -// processing for tapering a signal, without generating too much -// ripple in the frequency domain. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : array -// The triangular window, with the maximum value normalized to one -// (the value one appears only if the number of samples is odd), with -// the first and last samples equal to zero. -// -// See Also -// -------- -// blackman, hamming, hanning, kaiser -// -// Notes -// ----- -// The Bartlett window is defined as -// -// .. math:: w(n) = \frac{2}{M-1} \left( -// \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| -// \right) -// -// Most references to the Bartlett window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. Note that convolution with this window produces linear -// interpolation. It is also known as an apodization (which means "removing -// the foot", i.e. smoothing discontinuities at the beginning and end of the -// sampled signal) or tapering function. The Fourier transform of the -// Bartlett window is the product of two sinc functions. Note the excellent -// discussion in Kanasewich [2]_. -// -// References -// ---------- -// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", -// Biometrika 37, 1-16, 1950. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 109-110. -// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal -// Processing", Prentice-Hall, 1999, pp. 468-471. -// .. [4] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 429. -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.bartlett(12) -// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary -// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, -// 0.18181818, 0. ]) -// -// Plot the window and its frequency response (requires SciPy and matplotlib): -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.bartlett(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Bartlett window") -// Text(0.5, 1.0, 'Bartlett window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Bartlett window") -// Text(0.5, 1.0, 'Frequency response of Bartlett window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> _ = plt.axis('tight') -// >>> plt.show() -// -// -// -//go:linkname Bartlett py.bartlett -func Bartlett(M *py.Object) *py.Object -// -// Return the Blackman window. -// -// The Blackman window is a taper formed by using the first three -// terms of a summation of cosines. It was designed to have close to the -// minimal leakage possible. It is close to optimal, only slightly worse -// than a Kaiser window. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an empty -// array is returned. -// -// Returns -// ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value one -// appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, hamming, hanning, kaiser -// -// Notes -// ----- -// The Blackman window is defined as -// -// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) -// -// Most references to the Blackman window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. It is known as a -// "near optimal" tapering function, almost as good (by some measures) -// as the kaiser window. -// -// References -// ---------- -// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, -// Dover Publications, New York. -// -// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. -// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.blackman(12) -// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary -// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, -// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, -// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) -// -// Plot the window and the frequency response: -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.blackman(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Blackman window") -// Text(0.5, 1.0, 'Blackman window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Blackman window") -// Text(0.5, 1.0, 'Frequency response of Blackman window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> _ = plt.axis('tight') -// >>> plt.show() -// -// -// -//go:linkname Blackman py.blackman -func Blackman(M *py.Object) *py.Object -// -// Return the Kaiser window. -// -// The Kaiser window is a taper formed by using a Bessel function. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// beta : float -// Shape parameter for window. -// -// Returns -// ------- -// out : array -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, blackman, hamming, hanning -// -// Notes -// ----- -// The Kaiser window is defined as -// -// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} -// \right)/I_0(\beta) -// -// with -// -// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, -// -// where :math:`I_0` is the modified zeroth-order Bessel function. -// -// The Kaiser was named for Jim Kaiser, who discovered a simple -// approximation to the DPSS window based on Bessel functions. The Kaiser -// window is a very good approximation to the Digital Prolate Spheroidal -// Sequence, or Slepian window, which is the transform which maximizes the -// energy in the main lobe of the window relative to total energy. -// -// The Kaiser can approximate many other windows by varying the beta -// parameter. -// -// ==== ======================= -// beta Window shape -// ==== ======================= -// 0 Rectangular -// 5 Similar to a Hamming -// 6 Similar to a Hanning -// 8.6 Similar to a Blackman -// ==== ======================= -// -// A beta value of 14 is probably a good starting point. Note that as beta -// gets large, the window narrows, and so the number of samples needs to be -// large enough to sample the increasingly narrow spike, otherwise NaNs will -// get returned. -// -// Most references to the Kaiser window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. It is also known as an apodization (which means -// "removing the foot", i.e. smoothing discontinuities at the beginning -// and end of the sampled signal) or tapering function. -// -// References -// ---------- -// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by -// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. -// John Wiley and Sons, New York, (1966). -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 177-178. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.kaiser(12, 14) -// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary -// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, -// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, -// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) -// -// -// Plot the window and the frequency response: -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.kaiser(51, 14) -// >>> plt.plot(window) -// [] -// >>> plt.title("Kaiser window") -// Text(0.5, 1.0, 'Kaiser window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> response = 20 * np.log10(mag) -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Kaiser window") -// Text(0.5, 1.0, 'Frequency response of Kaiser window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// (-0.5, 0.5, -100.0, ...) # may vary -// >>> plt.show() -// -// -// -//go:linkname Kaiser py.kaiser -func Kaiser(M *py.Object, beta *py.Object) *py.Object -// -// Add documentation to an existing object, typically one defined in C -// -// The purpose is to allow easier editing of the docstrings without requiring -// a re-compile. This exists primarily for internal use within numpy itself. -// -// Parameters -// ---------- -// place : str -// The absolute name of the module to import from -// obj : str -// The name of the object to add documentation to, typically a class or -// function name -// doc : {str, Tuple[str, str], List[Tuple[str, str]]} -// If a string, the documentation to apply to `obj` -// -// If a tuple, then the first element is interpreted as an attribute of -// `obj` and the second as the docstring to apply - ``(method, docstring)`` -// -// If a list, then each element of the list should be a tuple of length -// two - ``[(method1, docstring1), (method2, docstring2), ...]`` -// warn_on_python : bool -// If True, the default, emit `UserWarning` if this is used to attach -// documentation to a pure-python object. -// -// Notes -// ----- -// This routine never raises an error if the docstring can't be written, but -// will raise an error if the object being documented does not exist. -// -// This routine cannot modify read-only docstrings, as appear -// in new-style classes or built-in functions. Because this -// routine never raises an error the caller must check manually -// that the docstrings were changed. -// -// Since this function grabs the ``char *`` from a c-level str object and puts -// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of -// C-API best-practices, by: -// -// - modifying a `PyTypeObject` after calling `PyType_Ready` -// - calling `Py_INCREF` on the str and losing the reference, so the str -// will never be released -// -// If possible it should be avoided. -// -// -//go:linkname AddNewdoc py.add_newdoc -func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object -// Find the wrapper for the array with the highest priority. -// -// In case of ties, leftmost wins. If no wrapper is found, return None -// -// -//go:linkname GetArrayWrap py.get_array_wrap -func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object -// -// Broadcast the input shapes into a single shape. -// -// :ref:`Learn more about broadcasting here `. -// -// .. versionadded:: 1.20.0 -// -// Parameters -// ---------- -// `*args` : tuples of ints, or ints -// The shapes to be broadcast against each other. -// -// Returns -// ------- -// tuple -// Broadcasted shape. -// -// Raises -// ------ -// ValueError -// If the shapes are not compatible and cannot be broadcast according -// to NumPy's broadcasting rules. -// -// See Also -// -------- -// broadcast -// broadcast_arrays -// broadcast_to -// -// Examples -// -------- -// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) -// (3, 2) -// -// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) -// (5, 6, 7) -// -// -//go:linkname BroadcastShapes py.broadcast_shapes -func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object -// -// Return a 2-D array with ones on the diagonal and zeros elsewhere. -// -// Parameters -// ---------- -// N : int -// Number of rows in the output. -// M : int, optional -// Number of columns in the output. If None, defaults to `N`. -// k : int, optional -// Index of the diagonal: 0 (the default) refers to the main diagonal, -// a positive value refers to an upper diagonal, and a negative value -// to a lower diagonal. -// dtype : data-type, optional -// Data-type of the returned array. -// order : {'C', 'F'}, optional -// Whether the output should be stored in row-major (C-style) or -// column-major (Fortran-style) order in memory. -// -// .. versionadded:: 1.14.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// I : ndarray of shape (N,M) -// An array where all elements are equal to zero, except for the `k`-th -// diagonal, whose values are equal to one. -// -// See Also -// -------- -// identity : (almost) equivalent function -// diag : diagonal 2-D array from a 1-D array specified by the user. -// -// Examples -// -------- -// >>> np.eye(2, dtype=int) -// array([[1, 0], -// [0, 1]]) -// >>> np.eye(3, k=1) -// array([[0., 1., 0.], -// [0., 0., 1.], -// [0., 0., 0.]]) -// -// -// -//go:linkname Eye py.eye -func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// An array with ones at and below the given diagonal and zeros elsewhere. -// -// Parameters -// ---------- -// N : int -// Number of rows in the array. -// M : int, optional -// Number of columns in the array. -// By default, `M` is taken equal to `N`. -// k : int, optional -// The sub-diagonal at and below which the array is filled. -// `k` = 0 is the main diagonal, while `k` < 0 is below it, -// and `k` > 0 is above. The default is 0. -// dtype : dtype, optional -// Data type of the returned array. The default is float. -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// tri : ndarray of shape (N, M) -// Array with its lower triangle filled with ones and zero elsewhere; -// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. -// -// Examples -// -------- -// >>> np.tri(3, 5, 2, dtype=int) -// array([[1, 1, 1, 0, 0], -// [1, 1, 1, 1, 0], -// [1, 1, 1, 1, 1]]) -// -// >>> np.tri(3, 5, -1) -// array([[0., 0., 0., 0., 0.], -// [1., 0., 0., 0., 0.], -// [1., 1., 0., 0., 0.]]) -// -// -// -//go:linkname Tri py.tri -func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object -// -// Return the indices to access (n, n) arrays, given a masking function. -// -// Assume `mask_func` is a function that, for a square array a of size -// ``(n, n)`` with a possible offset argument `k`, when called as -// ``mask_func(a, k)`` returns a new array with zeros in certain locations -// (functions like `triu` or `tril` do precisely this). Then this function -// returns the indices where the non-zero values would be located. -// -// Parameters -// ---------- -// n : int -// The returned indices will be valid to access arrays of shape (n, n). -// mask_func : callable -// A function whose call signature is similar to that of `triu`, `tril`. -// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. -// `k` is an optional argument to the function. -// k : scalar -// An optional argument which is passed through to `mask_func`. Functions -// like `triu`, `tril` take a second argument that is interpreted as an -// offset. -// -// Returns -// ------- -// indices : tuple of arrays. -// The `n` arrays of indices corresponding to the locations where -// ``mask_func(np.ones((n, n)), k)`` is True. -// -// See Also -// -------- -// triu, tril, triu_indices, tril_indices -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// These are the indices that would allow you to access the upper triangular -// part of any 3x3 array: -// -// >>> iu = np.mask_indices(3, np.triu) -// -// For example, if `a` is a 3x3 array: -// -// >>> a = np.arange(9).reshape(3, 3) -// >>> a -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) -// >>> a[iu] -// array([0, 1, 2, 4, 5, 8]) -// -// An offset can be passed also to the masking function. This gets us the -// indices starting on the first diagonal right of the main one: -// -// >>> iu1 = np.mask_indices(3, np.triu, 1) -// -// with which we now extract only three elements: -// -// >>> a[iu1] -// array([1, 2, 5]) -// -// -// -//go:linkname MaskIndices py.mask_indices -func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object -// -// Return the indices for the lower-triangle of an (n, m) array. -// -// Parameters -// ---------- -// n : int -// The row dimension of the arrays for which the returned -// indices will be valid. -// k : int, optional -// Diagonal offset (see `tril` for details). -// m : int, optional -// .. versionadded:: 1.9.0 -// -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. -// -// -// Returns -// ------- -// inds : tuple of arrays -// The indices for the triangle. The returned tuple contains two arrays, -// each with the indices along one dimension of the array. -// -// See also -// -------- -// triu_indices : similar function, for upper-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// tril, triu -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Compute two different sets of indices to access 4x4 arrays, one for the -// lower triangular part starting at the main diagonal, and one starting two -// diagonals further right: -// -// >>> il1 = np.tril_indices(4) -// >>> il2 = np.tril_indices(4, 2) -// -// Here is how they can be used with a sample array: -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Both for indexing: -// -// >>> a[il1] -// array([ 0, 4, 5, ..., 13, 14, 15]) -// -// And for assigning values: -// -// >>> a[il1] = -1 -// >>> a -// array([[-1, 1, 2, 3], -// [-1, -1, 6, 7], -// [-1, -1, -1, 11], -// [-1, -1, -1, -1]]) -// -// These cover almost the whole array (two diagonals right of the main one): -// -// >>> a[il2] = -10 -// >>> a -// array([[-10, -10, -10, 3], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10]]) -// -// -// -//go:linkname TrilIndices py.tril_indices -func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object -// -// Return the indices for the upper-triangle of an (n, m) array. -// -// Parameters -// ---------- -// n : int -// The size of the arrays for which the returned indices will -// be valid. -// k : int, optional -// Diagonal offset (see `triu` for details). -// m : int, optional -// .. versionadded:: 1.9.0 -// -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. -// -// -// Returns -// ------- -// inds : tuple, shape(2) of ndarrays, shape(`n`) -// The indices for the triangle. The returned tuple contains two arrays, -// each with the indices along one dimension of the array. Can be used -// to slice a ndarray of shape(`n`, `n`). -// -// See also -// -------- -// tril_indices : similar function, for lower-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// triu, tril -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Compute two different sets of indices to access 4x4 arrays, one for the -// upper triangular part starting at the main diagonal, and one starting two -// diagonals further right: -// -// >>> iu1 = np.triu_indices(4) -// >>> iu2 = np.triu_indices(4, 2) -// -// Here is how they can be used with a sample array: -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Both for indexing: -// -// >>> a[iu1] -// array([ 0, 1, 2, ..., 10, 11, 15]) -// -// And for assigning values: -// -// >>> a[iu1] = -1 -// >>> a -// array([[-1, -1, -1, -1], -// [ 4, -1, -1, -1], -// [ 8, 9, -1, -1], -// [12, 13, 14, -1]]) -// -// These cover only a small part of the whole array (two diagonals right -// of the main one): -// -// >>> a[iu2] = -10 -// >>> a -// array([[ -1, -1, -10, -10], -// [ 4, -1, -1, -10], -// [ 8, 9, -1, -1], -// [ 12, 13, 14, -1]]) -// -// -// -//go:linkname TriuIndices py.triu_indices -func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object -// -// Determine if a class is a subclass of a second class. -// -// `issubclass_` is equivalent to the Python built-in ``issubclass``, -// except that it returns False instead of raising a TypeError if one -// of the arguments is not a class. -// -// Parameters -// ---------- -// arg1 : class -// Input class. True is returned if `arg1` is a subclass of `arg2`. -// arg2 : class or tuple of classes. -// Input class. If a tuple of classes, True is returned if `arg1` is a -// subclass of any of the tuple elements. -// -// Returns -// ------- -// out : bool -// Whether `arg1` is a subclass of `arg2` or not. -// -// See Also -// -------- -// issubsctype, issubdtype, issctype -// -// Examples -// -------- -// >>> np.issubclass_(np.int32, int) -// False -// >>> np.issubclass_(np.int32, float) -// False -// >>> np.issubclass_(np.float64, float) -// True -// -// -// -//go:linkname Issubclass py.issubclass_ -func Issubclass(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Determine if the first argument is a subclass of the second argument. -// -// Parameters -// ---------- -// arg1, arg2 : dtype or dtype specifier -// Data-types. -// -// Returns -// ------- -// out : bool -// The result. -// -// See Also -// -------- -// issctype, issubdtype, obj2sctype -// -// Examples -// -------- -// >>> np.issubsctype('S8', str) -// False -// >>> np.issubsctype(np.array([1]), int) -// True -// >>> np.issubsctype(np.array([1]), float) -// False -// -// -// -//go:linkname Issubsctype py.issubsctype -func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Issues a DeprecationWarning, adds warning to `old_name`'s -// docstring, rebinds ``old_name.__name__`` and returns the new -// function object. -// -// This function may also be used as a decorator. -// -// Parameters -// ---------- -// func : function -// The function to be deprecated. -// old_name : str, optional -// The name of the function to be deprecated. Default is None, in -// which case the name of `func` is used. -// new_name : str, optional -// The new name for the function. Default is None, in which case the -// deprecation message is that `old_name` is deprecated. If given, the -// deprecation message is that `old_name` is deprecated and `new_name` -// should be used instead. -// message : str, optional -// Additional explanation of the deprecation. Displayed in the -// docstring after the warning. -// -// Returns -// ------- -// old_func : function -// The deprecated function. -// -// Examples -// -------- -// Note that ``olduint`` returns a value after printing Deprecation -// Warning: -// -// >>> olduint = np.deprecate(np.uint) -// DeprecationWarning: `uint64` is deprecated! # may vary -// >>> olduint(6) -// 6 -// -// -// -//go:linkname Deprecate py.deprecate -func Deprecate(__llgo_va_list ...interface{}) *py.Object -// -// Deprecates a function and includes the deprecation in its docstring. -// -// This function is used as a decorator. It returns an object that can be -// used to issue a DeprecationWarning, by passing the to-be decorated -// function as argument, this adds warning to the to-be decorated function's -// docstring and returns the new function object. -// -// See Also -// -------- -// deprecate : Decorate a function such that it issues a `DeprecationWarning` -// -// Parameters -// ---------- -// msg : str -// Additional explanation of the deprecation. Displayed in the -// docstring after the warning. -// -// Returns -// ------- -// obj : object -// -// -// -//go:linkname DeprecateWithDoc py.deprecate_with_doc -func DeprecateWithDoc(msg *py.Object) *py.Object -// -// Return the directory that contains the NumPy \*.h header files. -// -// Extension modules that need to compile against NumPy should use this -// function to locate the appropriate include directory. -// -// Notes -// ----- -// When using ``distutils``, for example in ``setup.py``:: -// -// import numpy as np -// ... -// Extension('extension_name', ... -// include_dirs=[np.get_include()]) -// ... -// -// -// -//go:linkname GetInclude py.get_include -func GetInclude() *py.Object -// -// Get help information for an array, function, class, or module. -// -// Parameters -// ---------- -// object : object or str, optional -// Input object or name to get information about. If `object` is -// an `ndarray` instance, information about the array is printed. -// If `object` is a numpy object, its docstring is given. If it is -// a string, available modules are searched for matching objects. -// If None, information about `info` itself is returned. -// maxwidth : int, optional -// Printing width. -// output : file like object, optional -// File like object that the output is written to, default is -// ``None``, in which case ``sys.stdout`` will be used. -// The object has to be opened in 'w' or 'a' mode. -// toplevel : str, optional -// Start search at this level. -// -// See Also -// -------- -// source, lookfor -// -// Notes -// ----- -// When used interactively with an object, ``np.info(obj)`` is equivalent -// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython -// prompt. -// -// Examples -// -------- -// >>> np.info(np.polyval) # doctest: +SKIP -// polyval(p, x) -// Evaluate the polynomial p at x. -// ... -// -// When using a string for `object` it is possible to get multiple results. -// -// >>> np.info('fft') # doctest: +SKIP -// *** Found in numpy *** -// Core FFT routines -// ... -// *** Found in numpy.fft *** -// fft(a, n=None, axis=-1) -// ... -// *** Repeat reference found in numpy.fft.fftpack *** -// *** Total of 3 references found. *** -// -// When the argument is an array, information about the array is printed. -// -// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) -// >>> np.info(a) -// class: ndarray -// shape: (2, 3) -// strides: (24, 8) -// itemsize: 8 -// aligned: True -// contiguous: True -// fortran: False -// data pointer: 0x562b6e0d2860 # may vary -// byteorder: little -// byteswap: False -// type: complex64 -// -// -// -//go:linkname Info py.info -func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object -// -// Print or write to a file the source code for a NumPy object. -// -// The source code is only returned for objects written in Python. Many -// functions and classes are defined in C and will therefore not return -// useful information. -// -// Parameters -// ---------- -// object : numpy object -// Input object. This can be any object (function, class, module, -// ...). -// output : file object, optional -// If `output` not supplied then source code is printed to screen -// (sys.stdout). File object must be created with either write 'w' or -// append 'a' modes. -// -// See Also -// -------- -// lookfor, info -// -// Examples -// -------- -// >>> np.source(np.interp) #doctest: +SKIP -// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py -// def interp(x, xp, fp, left=None, right=None): -// """.... (full docstring printed)""" -// if isinstance(x, (float, int, number)): -// return compiled_interp([x], xp, fp, left, right).item() -// else: -// return compiled_interp(x, xp, fp, left, right) -// -// The source code is only returned for objects written in Python. -// -// >>> np.source(np.array) #doctest: +SKIP -// Not available for this object. -// -// -// -//go:linkname Source py.source -func Source(object *py.Object, output *py.Object) *py.Object -// -// Print the NumPy arrays in the given dictionary. -// -// If there is no dictionary passed in or `vardict` is None then returns -// NumPy arrays in the globals() dictionary (all NumPy arrays in the -// namespace). -// -// Parameters -// ---------- -// vardict : dict, optional -// A dictionary possibly containing ndarrays. Default is globals(). -// -// Returns -// ------- -// out : None -// Returns 'None'. -// -// Notes -// ----- -// Prints out the name, shape, bytes and type of all of the ndarrays -// present in `vardict`. -// -// Examples -// -------- -// >>> a = np.arange(10) -// >>> b = np.ones(20) -// >>> np.who() -// Name Shape Bytes Type -// =========================================================== -// a 10 80 int64 -// b 20 160 float64 -// Upper bound on total bytes = 240 -// -// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', -// ... 'idx':5} -// >>> np.who(d) -// Name Shape Bytes Type -// =========================================================== -// x 2 16 float64 -// y 3 24 float64 -// Upper bound on total bytes = 40 -// -// -// -//go:linkname Who py.who -func Who(vardict *py.Object) *py.Object -// -// Do a keyword search on docstrings. -// -// A list of objects that matched the search is displayed, -// sorted by relevance. All given keywords need to be found in the -// docstring for it to be returned as a result, but the order does -// not matter. -// -// Parameters -// ---------- -// what : str -// String containing words to look for. -// module : str or list, optional -// Name of module(s) whose docstrings to go through. -// import_modules : bool, optional -// Whether to import sub-modules in packages. Default is True. -// regenerate : bool, optional -// Whether to re-generate the docstring cache. Default is False. -// output : file-like, optional -// File-like object to write the output to. If omitted, use a pager. -// -// See Also -// -------- -// source, info -// -// Notes -// ----- -// Relevance is determined only roughly, by checking if the keywords occur -// in the function name, at the start of a docstring, etc. -// -// Examples -// -------- -// >>> np.lookfor('binary representation') # doctest: +SKIP -// Search results for 'binary representation' -// ------------------------------------------ -// numpy.binary_repr -// Return the binary representation of the input number as a string. -// numpy.core.setup_common.long_double_representation -// Given a binary dump as given by GNU od -b, look for long double -// numpy.base_repr -// Return a string representation of a number in the given base system. -// ... -// -// -// -//go:linkname Lookfor py.lookfor -func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object -// -// Returns pointers to the end-points of an array. -// -// Parameters -// ---------- -// a : ndarray -// Input array. It must conform to the Python-side of the array -// interface. -// -// Returns -// ------- -// (low, high) : tuple of 2 integers -// The first integer is the first byte of the array, the second -// integer is just past the last byte of the array. If `a` is not -// contiguous it will not use every byte between the (`low`, `high`) -// values. -// -// Examples -// -------- -// >>> I = np.eye(2, dtype='f'); I.dtype -// dtype('float32') -// >>> low, high = np.byte_bounds(I) -// >>> high - low == I.size*I.itemsize -// True -// >>> I = np.eye(2); I.dtype -// dtype('float64') -// >>> low, high = np.byte_bounds(I) -// >>> high - low == I.size*I.itemsize -// True -// -// -// -//go:linkname ByteBounds py.byte_bounds -func ByteBounds(a *py.Object) *py.Object -// -// Protected string evaluation. -// -// Evaluate a string containing a Python literal expression without -// allowing the execution of arbitrary non-literal code. -// -// .. warning:: -// -// This function is identical to :py:meth:`ast.literal_eval` and -// has the same security implications. It may not always be safe -// to evaluate large input strings. -// -// Parameters -// ---------- -// source : str -// The string to evaluate. -// -// Returns -// ------- -// obj : object -// The result of evaluating `source`. -// -// Raises -// ------ -// SyntaxError -// If the code has invalid Python syntax, or if it contains -// non-literal code. -// -// Examples -// -------- -// >>> np.safe_eval('1') -// 1 -// >>> np.safe_eval('[1, 2, 3]') -// [1, 2, 3] -// >>> np.safe_eval('{"foo": ("bar", 10.0)}') -// {'foo': ('bar', 10.0)} -// -// >>> np.safe_eval('import os') -// Traceback (most recent call last): -// ... -// SyntaxError: invalid syntax -// -// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') -// Traceback (most recent call last): -// ... -// ValueError: malformed node or string: <_ast.Call object at 0x...> -// -// -// -//go:linkname SafeEval py.safe_eval -func SafeEval(source *py.Object) *py.Object -// -// Print information about various resources in the system -// including available intrinsic support and BLAS/LAPACK library -// in use -// -// .. versionadded:: 1.24.0 -// -// See Also -// -------- -// show_config : Show libraries in the system on which NumPy was built. -// -// Notes -// ----- -// 1. Information is derived with the help of `threadpoolctl `_ -// library if available. -// 2. SIMD related information is derived from ``__cpu_features__``, -// ``__cpu_baseline__`` and ``__cpu_dispatch__`` -// -// -// -//go:linkname ShowRuntime py.show_runtime -func ShowRuntime() *py.Object -// -// Load data from a text file. -// -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : data-type, optional -// Data-type of the resulting array; default: float. If this is a -// structured data-type, the resulting array will be 1-dimensional, and -// each row will be interpreted as an element of the array. In this -// case, the number of columns used must match the number of fields in -// the data-type. -// comments : str or sequence of str or None, optional -// The characters or list of characters used to indicate the start of a -// comment. None implies no comments. For backwards compatibility, byte -// strings will be decoded as 'latin1'. The default is '#'. -// delimiter : str, optional -// The character used to separate the values. For backwards compatibility, -// byte strings will be decoded as 'latin1'. The default is whitespace. -// -// .. versionchanged:: 1.23.0 -// Only single character delimiters are supported. Newline characters -// cannot be used as the delimiter. -// -// converters : dict or callable, optional -// Converter functions to customize value parsing. If `converters` is -// callable, the function is applied to all columns, else it must be a -// dict that maps column number to a parser function. -// See examples for further details. -// Default: None. -// -// .. versionchanged:: 1.23.0 -// The ability to pass a single callable to be applied to all columns -// was added. -// -// skiprows : int, optional -// Skip the first `skiprows` lines, including comments; default: 0. -// usecols : int or sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. -// The default, None, results in all columns being read. -// -// .. versionchanged:: 1.11.0 -// When a single column has to be read it is possible to use -// an integer instead of a tuple. E.g ``usecols = 3`` reads the -// fourth column the same way as ``usecols = (3,)`` would. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = loadtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// ndmin : int, optional -// The returned array will have at least `ndmin` dimensions. -// Otherwise mono-dimensional axes will be squeezed. -// Legal values: 0 (default), 1 or 2. -// -// .. versionadded:: 1.6.0 -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply to input streams. -// The special value 'bytes' enables backward compatibility workarounds -// that ensures you receive byte arrays as results if possible and passes -// 'latin1' encoded strings to converters. Override this value to receive -// unicode arrays and pass strings as input to converters. If set to None -// the system default is used. The default value is 'bytes'. -// -// .. versionadded:: 1.14.0 -// max_rows : int, optional -// Read `max_rows` rows of content after `skiprows` lines. The default is -// to read all the rows. Note that empty rows containing no data such as -// empty lines and comment lines are not counted towards `max_rows`, -// while such lines are counted in `skiprows`. -// -// .. versionadded:: 1.16.0 -// -// .. versionchanged:: 1.23.0 -// Lines containing no data, including comment lines (e.g., lines -// starting with '#' or as specified via `comments`) are not counted -// towards `max_rows`. -// quotechar : unicode character or None, optional -// The character used to denote the start and end of a quoted item. -// Occurrences of the delimiter or comment characters are ignored within -// a quoted item. The default value is ``quotechar=None``, which means -// quoting support is disabled. -// -// If two consecutive instances of `quotechar` are found within a quoted -// field, the first is treated as an escape character. See examples. -// -// .. versionadded:: 1.23.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Data read from the text file. -// -// See Also -// -------- -// load, fromstring, fromregex -// genfromtxt : Load data with missing values handled as specified. -// scipy.io.loadmat : reads MATLAB data files -// -// Notes -// ----- -// This function aims to be a fast reader for simply formatted files. The -// `genfromtxt` function provides more sophisticated handling of, e.g., -// lines with missing values. -// -// Each row in the input text file must have the same number of values to be -// able to read all values. If all rows do not have same number of values, a -// subset of up to n columns (where n is the least number of values present -// in all rows) can be read by specifying the columns via `usecols`. -// -// .. versionadded:: 1.10.0 -// -// The strings produced by the Python float.hex method can be used as -// input for floats. -// -// Examples -// -------- -// >>> from io import StringIO # StringIO behaves like a file object -// >>> c = StringIO("0 1\n2 3") -// >>> np.loadtxt(c) -// array([[0., 1.], -// [2., 3.]]) -// -// >>> d = StringIO("M 21 72\nF 35 58") -// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), -// ... 'formats': ('S1', 'i4', 'f4')}) -// array([(b'M', 21, 72.), (b'F', 35, 58.)], -// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") -// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) -// >>> x -// array([1., 3.]) -// >>> y -// array([2., 4.]) -// -// The `converters` argument is used to specify functions to preprocess the -// text prior to parsing. `converters` can be a dictionary that maps -// preprocessing functions to each column: -// -// >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n") -// >>> conv = { -// ... 0: lambda x: np.floor(float(x)), # conversion fn for column 0 -// ... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1 -// ... } -// >>> np.loadtxt(s, delimiter=",", converters=conv) -// array([[1., 3.], -// [3., 5.]]) -// -// `converters` can be a callable instead of a dictionary, in which case it -// is applied to all columns: -// -// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") -// >>> import functools -// >>> conv = functools.partial(int, base=16) -// >>> np.loadtxt(s, converters=conv) -// array([[222., 173.], -// [192., 222.]]) -// -// This example shows how `converters` can be used to convert a field -// with a trailing minus sign into a negative number. -// -// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') -// >>> def conv(fld): -// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) -// ... -// >>> np.loadtxt(s, converters=conv) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) -// -// Using a callable as the converter can be particularly useful for handling -// values with different formatting, e.g. floats with underscores: -// -// >>> s = StringIO("1 2.7 100_000") -// >>> np.loadtxt(s, converters=float) -// array([1.e+00, 2.7e+00, 1.e+05]) -// -// This idea can be extended to automatically handle values specified in -// many different formats: -// -// >>> def conv(val): -// ... try: -// ... return float(val) -// ... except ValueError: -// ... return float.fromhex(val) -// >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2") -// >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None) -// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) -// -// Note that with the default ``encoding="bytes"``, the inputs to the -// converter function are latin-1 encoded byte strings. To deactivate the -// implicit encoding prior to conversion, use ``encoding=None`` -// -// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') -// >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x) -// >>> np.loadtxt(s, converters=conv, encoding=None) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) -// -// Support for quoted fields is enabled with the `quotechar` parameter. -// Comment and delimiter characters are ignored when they appear within a -// quoted item delineated by `quotechar`: -// -// >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n') -// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) -// >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"') -// array([('alpha, #42', 10.), ('beta, #64', 2.)], -// dtype=[('label', '>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n') -// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) -// >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"') -// array([('alpha, #42', 10.), ('beta, #64', 2.)], -// dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"') -// >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"') -// array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20") -// >>> np.loadtxt(d, usecols=(0, 1)) -// array([[ 1., 2.], -// [ 2., 4.], -// [ 3., 9.], -// [ 4., 16.]]) -// -// -// -//go:linkname Loadtxt py.loadtxt -func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object -// -// Load data from a text file, with missing values handled as specified. -// -// Each line past the first `skip_header` lines is split at the `delimiter` -// character, and characters following the `comments` character are discarded. -// -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : dtype, optional -// Data type of the resulting array. -// If None, the dtypes will be determined by the contents of each -// column, individually. -// comments : str, optional -// The character used to indicate the start of a comment. -// All the characters occurring on a line after a comment are discarded. -// delimiter : str, int, or sequence, optional -// The string used to separate values. By default, any consecutive -// whitespaces act as delimiter. An integer or sequence of integers -// can also be provided as width(s) of each field. -// skiprows : int, optional -// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. -// skip_header : int, optional -// The number of lines to skip at the beginning of the file. -// skip_footer : int, optional -// The number of lines to skip at the end of the file. -// converters : variable, optional -// The set of functions that convert the data of a column to a value. -// The converters can also be used to provide a default value -// for missing data: ``converters = {3: lambda s: float(s or 0)}``. -// missing : variable, optional -// `missing` was removed in numpy 1.10. Please use `missing_values` -// instead. -// missing_values : variable, optional -// The set of strings corresponding to missing data. -// filling_values : variable, optional -// The set of values to be used as default when the data are missing. -// usecols : sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. -// names : {None, True, str, sequence}, optional -// If `names` is True, the field names are read from the first line after -// the first `skip_header` lines. This line can optionally be preceded -// by a comment delimiter. If `names` is a sequence or a single-string of -// comma-separated names, the names will be used to define the field names -// in a structured dtype. If `names` is None, the names of the dtype -// fields will be used, if any. -// excludelist : sequence, optional -// A list of names to exclude. This list is appended to the default list -// ['return','file','print']. Excluded names are appended with an -// underscore: for example, `file` would become `file_`. -// deletechars : str, optional -// A string combining invalid characters that must be deleted from the -// names. -// defaultfmt : str, optional -// A format used to define default field names, such as "f%i" or "f_%02i". -// autostrip : bool, optional -// Whether to automatically strip white spaces from the variables. -// replace_space : char, optional -// Character(s) used in replacement of white spaces in the variable -// names. By default, use a '_'. -// case_sensitive : {True, False, 'upper', 'lower'}, optional -// If True, field names are case sensitive. -// If False or 'upper', field names are converted to upper case. -// If 'lower', field names are converted to lower case. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = genfromtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// usemask : bool, optional -// If True, return a masked array. -// If False, return a regular array. -// loose : bool, optional -// If True, do not raise errors for invalid values. -// invalid_raise : bool, optional -// If True, an exception is raised if an inconsistency is detected in the -// number of columns. -// If False, a warning is emitted and the offending lines are skipped. -// max_rows : int, optional -// The maximum number of rows to read. Must not be used with skip_footer -// at the same time. If given, the value must be at least 1. Default is -// to read the entire file. -// -// .. versionadded:: 1.10.0 -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply when `fname` is -// a file object. The special value 'bytes' enables backward compatibility -// workarounds that ensure that you receive byte arrays when possible -// and passes latin1 encoded strings to converters. Override this value to -// receive unicode arrays and pass strings as input to converters. If set -// to None the system default is used. The default value is 'bytes'. -// -// .. versionadded:: 1.14.0 -// ndmin : int, optional -// Same parameter as `loadtxt` -// -// .. versionadded:: 1.23.0 -// like : array_like, optional -// Reference object to allow the creation of arrays which are not -// NumPy arrays. If an array-like passed in as ``like`` supports -// the ``__array_function__`` protocol, the result will be defined -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Data read from the text file. If `usemask` is True, this is a -// masked array. -// -// See Also -// -------- -// numpy.loadtxt : equivalent function when no data is missing. -// -// Notes -// ----- -// * When spaces are used as delimiters, or when no delimiter has been given -// as input, there should not be any missing data between two fields. -// * When the variables are named (either by a flexible dtype or with `names`), -// there must not be any header in the file (else a ValueError -// exception is raised). -// * Individual values are not stripped of spaces by default. -// When using a custom converter, make sure the function does remove spaces. -// -// References -// ---------- -// .. [1] NumPy User Guide, section `I/O with NumPy -// `_. -// -// Examples -// -------- -// >>> from io import StringIO -// >>> import numpy as np -// -// Comma delimited file with mixed dtype -// -// >>> s = StringIO(u"1,1.3,abcde") -// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), -// ... ('mystring','S5')], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only -// >>> data = np.genfromtxt(s, dtype=None, -// ... names = ['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) -// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", -// ... names=['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> s = StringIO(u"11.3abcde") -// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], -// ... delimiter=[1,3,5]) -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('intvar', '>> f = StringIO(''' -// ... text,# of chars -// ... hello world,11 -// ... numpy,5''') -// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') -// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], -// dtype=[('f0', 'S12'), ('f1', 'S12')]) -// -// -// -//go:linkname Genfromtxt py.genfromtxt -func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object -// -// Load ASCII data from a file and return it in a record array. -// -// If ``usemask=False`` a standard `recarray` is returned, -// if ``usemask=True`` a MaskedRecords array is returned. -// -// Parameters -// ---------- -// fname, kwargs : For a description of input parameters, see `genfromtxt`. -// -// See Also -// -------- -// numpy.genfromtxt : generic function -// -// Notes -// ----- -// By default, `dtype` is None, which means that the data-type of the output -// array will be determined from the data. -// -// -// -//go:linkname Recfromtxt py.recfromtxt -func Recfromtxt(fname *py.Object) *py.Object -// -// Load ASCII data stored in a comma-separated file. -// -// The returned array is a record array (if ``usemask=False``, see -// `recarray`) or a masked record array (if ``usemask=True``, -// see `ma.mrecords.MaskedRecords`). -// -// Parameters -// ---------- -// fname, kwargs : For a description of input parameters, see `genfromtxt`. -// -// See Also -// -------- -// numpy.genfromtxt : generic function to load ASCII data. -// -// Notes -// ----- -// By default, `dtype` is None, which means that the data-type of the output -// array will be determined from the data. -// -// -// -//go:linkname Recfromcsv py.recfromcsv -func Recfromcsv(fname *py.Object) *py.Object -// -// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. -// -// .. warning:: Loading files that contain object arrays uses the ``pickle`` -// module, which is not secure against erroneous or maliciously -// constructed data. Consider passing ``allow_pickle=False`` to -// load data that is known not to contain object arrays for the -// safer handling of untrusted sources. -// -// Parameters -// ---------- -// file : file-like object, string, or pathlib.Path -// The file to read. File-like objects must support the -// ``seek()`` and ``read()`` methods and must always -// be opened in binary mode. Pickled files require that the -// file-like object support the ``readline()`` method as well. -// mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional -// If not None, then memory-map the file, using the given mode (see -// `numpy.memmap` for a detailed description of the modes). A -// memory-mapped array is kept on disk. However, it can be accessed -// and sliced like any ndarray. Memory mapping is especially useful -// for accessing small fragments of large files without reading the -// entire file into memory. -// allow_pickle : bool, optional -// Allow loading pickled object arrays stored in npy files. Reasons for -// disallowing pickles include security, as loading pickled data can -// execute arbitrary code. If pickles are disallowed, loading object -// arrays will fail. Default: False -// -// .. versionchanged:: 1.16.3 -// Made default False in response to CVE-2019-6446. -// -// fix_imports : bool, optional -// Only useful when loading Python 2 generated pickled files on Python 3, -// which includes npy/npz files containing object arrays. If `fix_imports` -// is True, pickle will try to map the old Python 2 names to the new names -// used in Python 3. -// encoding : str, optional -// What encoding to use when reading Python 2 strings. Only useful when -// loading Python 2 generated pickled files in Python 3, which includes -// npy/npz files containing object arrays. Values other than 'latin1', -// 'ASCII', and 'bytes' are not allowed, as they can corrupt numerical -// data. Default: 'ASCII' -// max_header_size : int, optional -// Maximum allowed size of the header. Large headers may not be safe -// to load securely and thus require explicitly passing a larger value. -// See :py:func:`ast.literal_eval()` for details. -// This option is ignored when `allow_pickle` is passed. In that case -// the file is by definition trusted and the limit is unnecessary. -// -// Returns -// ------- -// result : array, tuple, dict, etc. -// Data stored in the file. For ``.npz`` files, the returned instance -// of NpzFile class must be closed to avoid leaking file descriptors. -// -// Raises -// ------ -// OSError -// If the input file does not exist or cannot be read. -// UnpicklingError -// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. -// ValueError -// The file contains an object array, but ``allow_pickle=False`` given. -// EOFError -// When calling ``np.load`` multiple times on the same file handle, -// if all data has already been read -// -// See Also -// -------- -// save, savez, savez_compressed, loadtxt -// memmap : Create a memory-map to an array stored in a file on disk. -// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. -// -// Notes -// ----- -// - If the file contains pickle data, then whatever object is stored -// in the pickle is returned. -// - If the file is a ``.npy`` file, then a single array is returned. -// - If the file is a ``.npz`` file, then a dictionary-like object is -// returned, containing ``{filename: array}`` key-value pairs, one for -// each file in the archive. -// - If the file is a ``.npz`` file, the returned value supports the -// context manager protocol in a similar fashion to the open function:: -// -// with load('foo.npz') as data: -// a = data['a'] -// -// The underlying file descriptor is closed when exiting the 'with' -// block. -// -// Examples -// -------- -// Store data to disk, and load it again: -// -// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) -// >>> np.load('/tmp/123.npy') -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// Store compressed data to disk, and load it again: -// -// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) -// >>> b=np.array([1, 2]) -// >>> np.savez('/tmp/123.npz', a=a, b=b) -// >>> data = np.load('/tmp/123.npz') -// >>> data['a'] -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> data['b'] -// array([1, 2]) -// >>> data.close() -// -// Mem-map the stored array, and then access the second row -// directly from disk: -// -// >>> X = np.load('/tmp/123.npy', mmap_mode='r') -// >>> X[1, :] -// memmap([4, 5, 6]) -// -// -// -//go:linkname Load py.load -func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object -// -// Construct an array from a text file, using regular expression parsing. -// -// The returned array is always a structured array, and is constructed from -// all matches of the regular expression in the file. Groups in the regular -// expression are converted to fields of the structured array. -// -// Parameters -// ---------- -// file : path or file -// Filename or file object to read. -// -// .. versionchanged:: 1.22.0 -// Now accepts `os.PathLike` implementations. -// regexp : str or regexp -// Regular expression used to parse the file. -// Groups in the regular expression correspond to fields in the dtype. -// dtype : dtype or list of dtypes -// Dtype for the structured array; must be a structured datatype. -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply to input streams. -// -// .. versionadded:: 1.14.0 -// -// Returns -// ------- -// output : ndarray -// The output array, containing the part of the content of `file` that -// was matched by `regexp`. `output` is always a structured array. -// -// Raises -// ------ -// TypeError -// When `dtype` is not a valid dtype for a structured array. -// -// See Also -// -------- -// fromstring, loadtxt -// -// Notes -// ----- -// Dtypes for structured arrays can be specified in several forms, but all -// forms specify at least the data type and field name. For details see -// `basics.rec`. -// -// Examples -// -------- -// >>> from io import StringIO -// >>> text = StringIO("1312 foo\n1534 bar\n444 qux") -// -// >>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything] -// >>> output = np.fromregex(text, regexp, -// ... [('num', np.int64), ('key', 'S3')]) -// >>> output -// array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')], -// dtype=[('num', '>> output['num'] -// array([1312, 1534, 444]) -// -// -// -//go:linkname Fromregex py.fromregex -func Fromregex(file *py.Object, regexp *py.Object, dtype *py.Object, encoding *py.Object) *py.Object -// -// Build a matrix object from a string, nested sequence, or array. -// -// Parameters -// ---------- -// obj : str or array_like -// Input data. If a string, variables in the current scope may be -// referenced by name. -// ldict : dict, optional -// A dictionary that replaces local operands in current frame. -// Ignored if `obj` is not a string or `gdict` is None. -// gdict : dict, optional -// A dictionary that replaces global operands in current frame. -// Ignored if `obj` is not a string. -// -// Returns -// ------- -// out : matrix -// Returns a matrix object, which is a specialized 2-D array. -// -// See Also -// -------- -// block : -// A generalization of this function for N-d arrays, that returns normal -// ndarrays. -// -// Examples -// -------- -// >>> A = np.mat('1 1; 1 1') -// >>> B = np.mat('2 2; 2 2') -// >>> C = np.mat('3 4; 5 6') -// >>> D = np.mat('7 8; 9 0') -// -// All the following expressions construct the same block matrix: -// -// >>> np.bmat([[A, B], [C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat('A,B; C,D') -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// -// -// -//go:linkname Bmat py.bmat -func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object -// -// Interpret the input as a matrix. -// -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. -// -// Parameters -// ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. -// -// Returns -// ------- -// mat : matrix -// `data` interpreted as a matrix. -// -// Examples -// -------- -// >>> x = np.array([[1, 2], [3, 4]]) -// -// >>> m = np.asmatrix(x) -// -// >>> x[0,0] = 5 -// -// >>> m -// matrix([[5, 2], -// [3, 4]]) -// -// -// -//go:linkname Mat py.mat -func Mat(data *py.Object, dtype *py.Object) *py.Object -// -// Interpret the input as a matrix. -// -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. -// -// Parameters -// ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. -// -// Returns -// ------- -// mat : matrix -// `data` interpreted as a matrix. -// -// Examples -// -------- -// >>> x = np.array([[1, 2], [3, 4]]) -// -// >>> m = np.asmatrix(x) -// -// >>> x[0,0] = 5 -// -// >>> m -// matrix([[5, 2], -// [3, 4]]) -// -// -// -//go:linkname Asmatrix py.asmatrix -func Asmatrix(data *py.Object, dtype *py.Object) *py.Object -// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the absolute value element-wise. -// -// ``np.abs`` is a shorthand for this function. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// 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. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// absolute : ndarray -// An ndarray containing the absolute value of -// each element in `x`. For complex input, ``a + ib``, the -// absolute value is :math:`\sqrt{ a^2 + b^2 }`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> x = np.array([-1.2, 1.2]) -// >>> np.absolute(x) -// array([ 1.2, 1.2]) -// >>> np.absolute(1.2 + 1j) -// 1.5620499351813308 -// -// Plot the function over ``[-10, 10]``: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(start=-10, stop=10, num=101) -// >>> plt.plot(x, np.absolute(x)) -// >>> plt.show() -// -// Plot the function over the complex plane: -// -// >>> xx = x + 1j * x[:, np.newaxis] -// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') -// >>> plt.show() -// -// The `abs` function can be used as a shorthand for ``np.absolute`` on -// ndarrays. -// -// >>> x = np.array([-1.2, 1.2]) -// >>> abs(x) -// array([1.2, 1.2]) -// -//go:linkname Abs py.abs -func Abs(__llgo_va_list ...interface{}) *py.Object diff --git a/numpy/numpy_autogen_link.go b/numpy/numpy_autogen_link.go deleted file mode 100644 index bb5882ce..00000000 --- a/numpy/numpy_autogen_link.go +++ /dev/null @@ -1,5 +0,0 @@ -package numpy - -import _ "github.com/goplus/lib/py" - -// LLGoPackage is defined in the main binding file From 2179dfde56f9154a454c63b2a5f8ff12d7a2905b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=A2=E7=A7=80=E7=85=8C?= Date: Fri, 15 Aug 2025 10:18:40 +0800 Subject: [PATCH 13/13] Release-as: numpy/v1.26.4 --- .DS_Store | Bin 8196 -> 8196 bytes numpy/_demo/main.go | 9 + numpy/go.mod | 5 + numpy/go.sum | 2 + numpy/llpkg.cfg | 16 + numpy/llpyg.cfg | 155 + numpy/numpy.go | 9572 +++++++++++++++++++++++++++++++++++ numpy/numpy_autogen_link.go | 5 + 8 files changed, 9764 insertions(+) create mode 100644 numpy/_demo/main.go create mode 100644 numpy/go.mod create mode 100644 numpy/go.sum create mode 100644 numpy/llpkg.cfg create mode 100644 numpy/llpyg.cfg create mode 100644 numpy/numpy.go create mode 100644 numpy/numpy_autogen_link.go diff --git a/.DS_Store b/.DS_Store index 6e2fecf8339e131c3e3283fa10bc1f2ce5f561b0..030b11dc417b30d9bfa29acdc9f74e1040d1c1ee 100644 GIT binary patch delta 43 zcmZp1XmQwZSa@=zP$`F@xq*&?p|R0qI}z#0ABEI5*Ne0H>> grid = np.indices((2, 3)) +// >>> grid.shape +// (2, 2, 3) +// >>> grid[0] # row indices +// array([[0, 0, 0], +// [1, 1, 1]]) +// >>> grid[1] # column indices +// array([[0, 1, 2], +// [0, 1, 2]]) +// +// The indices can be used as an index into an array. +// +// >>> x = np.arange(20).reshape(5, 4) +// >>> row, col = np.indices((2, 3)) +// >>> x[row, col] +// array([[0, 1, 2], +// [4, 5, 6]]) +// +// Note that it would be more straightforward in the above example to +// extract the required elements directly with ``x[:2, :3]``. +// +// If sparse is set to true, the grid will be returned in a sparse +// representation. +// +// >>> i, j = np.indices((2, 3), sparse=True) +// >>> i.shape +// (2, 1) +// >>> j.shape +// (1, 3) +// >>> i # row indices +// array([[0], +// [1]]) +// >>> j # column indices +// array([[0, 1, 2]]) +// +// +// +//go:linkname Indices py.indices +func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object +// +// Construct an array by executing a function over each coordinate. +// +// The resulting array therefore has a value ``fn(x, y, z)`` at +// coordinate ``(x, y, z)``. +// +// Parameters +// ---------- +// function : callable +// The function is called with N parameters, where N is the rank of +// `shape`. Each parameter represents the coordinates of the array +// varying along a specific axis. For example, if `shape` +// were ``(2, 2)``, then the parameters would be +// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` +// shape : (N,) tuple of ints +// Shape of the output array, which also determines the shape of +// the coordinate arrays passed to `function`. +// dtype : data-type, optional +// Data-type of the coordinate arrays passed to `function`. +// By default, `dtype` is float. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// fromfunction : any +// The result of the call to `function` is passed back directly. +// Therefore the shape of `fromfunction` is completely determined by +// `function`. If `function` returns a scalar value, the shape of +// `fromfunction` would not match the `shape` parameter. +// +// See Also +// -------- +// indices, meshgrid +// +// Notes +// ----- +// Keywords other than `dtype` and `like` are passed to `function`. +// +// Examples +// -------- +// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) +// array([[0., 0.], +// [1., 1.]]) +// +// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) +// array([[0., 1.], +// [0., 1.]]) +// +// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) +// array([[ True, False, False], +// [False, True, False], +// [False, False, True]]) +// +// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) +// array([[0, 1, 2], +// [1, 2, 3], +// [2, 3, 4]]) +// +// +// +//go:linkname Fromfunction py.fromfunction +func Fromfunction(function *py.Object, shape *py.Object) *py.Object +// +// Returns True if the type of `element` is a scalar type. +// +// Parameters +// ---------- +// element : any +// Input argument, can be of any type and shape. +// +// Returns +// ------- +// val : bool +// True if `element` is a scalar type, False if it is not. +// +// See Also +// -------- +// ndim : Get the number of dimensions of an array +// +// Notes +// ----- +// If you need a stricter way to identify a *numerical* scalar, use +// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most +// non-numerical elements such as strings. +// +// In most 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: +// +// +--------------------------------------+---------------+-------------------+ +// | x |``isscalar(x)``|``np.ndim(x) == 0``| +// +======================================+===============+===================+ +// | PEP 3141 numeric objects (including | ``True`` | ``True`` | +// | builtins) | | | +// +--------------------------------------+---------------+-------------------+ +// | builtin string and buffer objects | ``True`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other builtin objects, like | ``False`` | ``True`` | +// | `pathlib.Path`, `Exception`, | | | +// | the result of `re.compile` | | | +// +--------------------------------------+---------------+-------------------+ +// | third-party objects like | ``False`` | ``True`` | +// | `matplotlib.figure.Figure` | | | +// +--------------------------------------+---------------+-------------------+ +// | zero-dimensional numpy arrays | ``False`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other numpy arrays | ``False`` | ``False`` | +// +--------------------------------------+---------------+-------------------+ +// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | +// | objects | | | +// +--------------------------------------+---------------+-------------------+ +// +// Examples +// -------- +// >>> np.isscalar(3.1) +// True +// >>> np.isscalar(np.array(3.1)) +// False +// >>> np.isscalar([3.1]) +// False +// >>> np.isscalar(False) +// True +// >>> np.isscalar('numpy') +// True +// +// NumPy supports PEP 3141 numbers: +// +// >>> from fractions import Fraction +// >>> np.isscalar(Fraction(5, 17)) +// True +// >>> from numbers import Number +// >>> np.isscalar(Number()) +// True +// +// +// +//go:linkname Isscalar py.isscalar +func Isscalar(element *py.Object) *py.Object +// +// Return the binary representation of the input number as a string. +// +// For negative numbers, if width is not given, a minus sign is added to the +// front. If width is given, the two's complement of the number is +// returned, with respect to that width. +// +// In a two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit two's-complement +// system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// num : int +// Only an integer decimal number can be used. +// width : int, optional +// The length of the returned string if `num` is positive, or the length +// of the two's complement if `num` is negative, provided that `width` is +// at least a sufficient number of bits for `num` to be represented in the +// designated form. +// +// If the `width` value is insufficient, it will be ignored, and `num` will +// be returned in binary (`num` > 0) or two's complement (`num` < 0) form +// with its width equal to the minimum number of bits needed to represent +// the number in the designated form. This behavior is deprecated and will +// later raise an error. +// +// .. deprecated:: 1.12.0 +// +// Returns +// ------- +// bin : str +// Binary representation of `num` or two's complement of `num`. +// +// See Also +// -------- +// base_repr: Return a string representation of a number in the given base +// system. +// bin: Python's built-in binary representation generator of an integer. +// +// Notes +// ----- +// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x +// faster. +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// >>> np.binary_repr(3) +// '11' +// >>> np.binary_repr(-3) +// '-11' +// >>> np.binary_repr(3, width=4) +// '0011' +// +// The two's complement is returned when the input number is negative and +// width is specified: +// +// >>> np.binary_repr(-3, width=3) +// '101' +// >>> np.binary_repr(-3, width=5) +// '11101' +// +// +// +//go:linkname BinaryRepr py.binary_repr +func BinaryRepr(num *py.Object, width *py.Object) *py.Object +// +// Return a string representation of a number in the given base system. +// +// Parameters +// ---------- +// number : int +// The value to convert. Positive and negative values are handled. +// base : int, optional +// Convert `number` to the `base` number system. The valid range is 2-36, +// the default value is 2. +// padding : int, optional +// Number of zeros padded on the left. Default is 0 (no padding). +// +// Returns +// ------- +// out : str +// String representation of `number` in `base` system. +// +// See Also +// -------- +// binary_repr : Faster version of `base_repr` for base 2. +// +// Examples +// -------- +// >>> np.base_repr(5) +// '101' +// >>> np.base_repr(6, 5) +// '11' +// >>> np.base_repr(7, base=5, padding=3) +// '00012' +// +// >>> np.base_repr(10, base=16) +// 'A' +// >>> np.base_repr(32, base=16) +// '20' +// +// +// +//go:linkname BaseRepr py.base_repr +func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object +// +// Return a new array of given shape and type, filled with ones. +// +// Parameters +// ---------- +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// dtype : data-type, optional +// The desired data-type for the array, e.g., `numpy.int8`. Default is +// `numpy.float64`. +// order : {'C', 'F'}, optional, default: C +// Whether to store multi-dimensional data in row-major +// (C-style) or column-major (Fortran-style) order in +// memory. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of ones with the given shape, dtype, and order. +// +// See Also +// -------- +// ones_like : Return an array of ones with shape and type of input. +// empty : Return a new uninitialized array. +// zeros : Return a new array setting values to zero. +// full : Return a new array of given shape filled with value. +// +// +// Examples +// -------- +// >>> np.ones(5) +// array([1., 1., 1., 1., 1.]) +// +// >>> np.ones((5,), dtype=int) +// array([1, 1, 1, 1, 1]) +// +// >>> np.ones((2, 1)) +// array([[1.], +// [1.]]) +// +// >>> s = (2,2) +// >>> np.ones(s) +// array([[1., 1.], +// [1., 1.]]) +// +// +// +//go:linkname Ones py.ones +func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// Return the identity array. +// +// The identity array is a square array with ones on +// the main diagonal. +// +// Parameters +// ---------- +// n : int +// Number of rows (and columns) in `n` x `n` output. +// dtype : data-type, optional +// Data-type of the output. Defaults to ``float``. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// `n` x `n` array with its main diagonal set to one, +// and all other elements 0. +// +// Examples +// -------- +// >>> np.identity(3) +// array([[1., 0., 0.], +// [0., 1., 0.], +// [0., 0., 1.]]) +// +// +// +//go:linkname Identity py.identity +func Identity(n *py.Object, dtype *py.Object) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. +// +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: +// +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' +// +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) +// +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) +// +//go:linkname BitwiseNot py.bitwise_not +func BitwiseNot(__llgo_va_list ...interface{}) *py.Object +// +// Return a new array of given shape and type, filled with `fill_value`. +// +// Parameters +// ---------- +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// fill_value : scalar or array_like +// Fill value. +// dtype : data-type, optional +// The desired data-type for the array The default, None, means +// ``np.array(fill_value).dtype``. +// order : {'C', 'F'}, optional +// Whether to store multidimensional data in C- or Fortran-contiguous +// (row- or column-wise) order in memory. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of `fill_value` with the given shape, dtype, and order. +// +// See Also +// -------- +// full_like : Return a new array with shape of input filled with value. +// empty : Return a new uninitialized array. +// ones : Return a new array setting values to one. +// zeros : Return a new array setting values to zero. +// +// Examples +// -------- +// >>> np.full((2, 2), np.inf) +// array([[inf, inf], +// [inf, inf]]) +// >>> np.full((2, 2), 10) +// array([[10, 10], +// [10, 10]]) +// +// >>> np.full((2, 2), [1, 2]) +// array([[1, 2], +// [1, 2]]) +// +// +// +//go:linkname Full py.full +func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object +// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) +// +// Matrix product of two arrays. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays, scalars not allowed. +// out : ndarray, optional +// A location into which the result is stored. If provided, it must have +// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not +// provided or None, a freshly-allocated array is returned. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// .. versionadded:: 1.16 +// Now handles ufunc kwargs +// +// Returns +// ------- +// y : ndarray +// The matrix product of the inputs. +// This is a scalar only when both x1, x2 are 1-d vectors. +// +// Raises +// ------ +// ValueError +// If the last dimension of `x1` is not the same size as +// the second-to-last dimension of `x2`. +// +// If a scalar value is passed in. +// +// See Also +// -------- +// vdot : Complex-conjugating dot product. +// tensordot : Sum products over arbitrary axes. +// einsum : Einstein summation convention. +// dot : alternative matrix product with different broadcasting rules. +// +// Notes +// ----- +// +// The behavior depends on the arguments in the following way. +// +// - If both arguments are 2-D they are multiplied like conventional +// matrices. +// - If either argument is N-D, N > 2, it is treated as a stack of +// matrices residing in the last two indexes and broadcast accordingly. +// - If the first argument is 1-D, it is promoted to a matrix by +// prepending a 1 to its dimensions. After matrix multiplication +// the prepended 1 is removed. +// - If the second argument is 1-D, it is promoted to a matrix by +// appending a 1 to its dimensions. After matrix multiplication +// the appended 1 is removed. +// +// ``matmul`` differs from ``dot`` in two important ways: +// +// - Multiplication by scalars is not allowed, use ``*`` instead. +// - Stacks of matrices are broadcast together as if the matrices +// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: +// +// >>> a = np.ones([9, 5, 7, 4]) +// >>> c = np.ones([9, 5, 4, 3]) +// >>> np.dot(a, c).shape +// (9, 5, 7, 9, 5, 3) +// >>> np.matmul(a, c).shape +// (9, 5, 7, 3) +// >>> # n is 7, k is 4, m is 3 +// +// The matmul function implements the semantics of the ``@`` operator +// introduced in Python 3.5 following :pep:`465`. +// +// It uses an optimized BLAS library when possible (see `numpy.linalg`). +// +// Examples +// -------- +// For 2-D arrays it is the matrix product: +// +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([[4, 1], +// ... [2, 2]]) +// >>> np.matmul(a, b) +// array([[4, 1], +// [2, 2]]) +// +// For 2-D mixed with 1-D, the result is the usual. +// +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([1, 2]) +// >>> np.matmul(a, b) +// array([1, 2]) +// >>> np.matmul(b, a) +// array([1, 2]) +// +// +// Broadcasting is conventional for stacks of arrays +// +// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) +// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) +// >>> np.matmul(a,b).shape +// (2, 2, 2) +// >>> np.matmul(a, b)[0, 1, 1] +// 98 +// >>> sum(a[0, 1, :] * b[0 , :, 1]) +// 98 +// +// Vector, vector returns the scalar inner product, but neither argument +// is complex-conjugated: +// +// >>> np.matmul([2j, 3j], [2j, 3j]) +// (-13+0j) +// +// Scalar multiplication raises an error. +// +// >>> np.matmul([1,2], 3) +// Traceback (most recent call last): +// ... +// ValueError: matmul: Input operand 1 does not have enough dimensions ... +// +// The ``@`` operator can be used as a shorthand for ``np.matmul`` on +// ndarrays. +// +// >>> x1 = np.array([2j, 3j]) +// >>> x2 = np.array([2j, 3j]) +// >>> x1 @ x2 +// (-13+0j) +// +// .. versionadded:: 1.10.0 +// +//go:linkname Matmul py.matmul +func Matmul(__llgo_va_list ...interface{}) *py.Object +// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the absolute value element-wise. +// +// ``np.abs`` is a shorthand for this function. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// absolute : ndarray +// An ndarray containing the absolute value of +// each element in `x`. For complex input, ``a + ib``, the +// absolute value is :math:`\sqrt{ a^2 + b^2 }`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> x = np.array([-1.2, 1.2]) +// >>> np.absolute(x) +// array([ 1.2, 1.2]) +// >>> np.absolute(1.2 + 1j) +// 1.5620499351813308 +// +// Plot the function over ``[-10, 10]``: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(start=-10, stop=10, num=101) +// >>> plt.plot(x, np.absolute(x)) +// >>> plt.show() +// +// Plot the function over the complex plane: +// +// >>> xx = x + 1j * x[:, np.newaxis] +// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') +// >>> plt.show() +// +// The `abs` function can be used as a shorthand for ``np.absolute`` on +// ndarrays. +// +// >>> x = np.array([-1.2, 1.2]) +// >>> abs(x) +// array([1.2, 1.2]) +// +//go:linkname Absolute py.absolute +func Absolute(__llgo_va_list ...interface{}) *py.Object +// add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Add arguments element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays to be added. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// add : ndarray or scalar +// The sum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to `x1` + `x2` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.add(1.0, 4.0) +// 5.0 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.add(x1, x2) +// array([[ 0., 2., 4.], +// [ 3., 5., 7.], +// [ 6., 8., 10.]]) +// +// The ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 + x2 +// array([[ 0., 2., 4.], +// [ 3., 5., 7.], +// [ 6., 8., 10.]]) +// +//go:linkname Add py.add +func Add(__llgo_va_list ...interface{}) *py.Object +// arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric inverse cosine, element-wise. +// +// The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``. +// +// Parameters +// ---------- +// x : array_like +// `x`-coordinate on the unit circle. +// For real arguments, the domain is [-1, 1]. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// The angle of the ray intersecting the unit circle at the given +// `x`-coordinate in radians [0, pi]. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// cos, arctan, arcsin, emath.arccos +// +// Notes +// ----- +// `arccos` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``cos(z) = x``. The convention is to return +// the angle `z` whose real part lies in `[0, pi]`. +// +// For real-valued input data types, `arccos` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse `cos` is also known as `acos` or cos^-1. +// +// References +// ---------- +// M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// We expect the arccos of 1 to be 0, and of -1 to be pi: +// +// >>> np.arccos([1, -1]) +// array([ 0. , 3.14159265]) +// +// Plot arccos: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-1, 1, num=100) +// >>> plt.plot(x, np.arccos(x)) +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Arccos py.arccos +func Arccos(__llgo_va_list ...interface{}) *py.Object +// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic cosine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// arccosh : ndarray +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// +// cosh, arcsinh, sinh, arctanh, tanh +// +// Notes +// ----- +// `arccosh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `cosh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in +// ``[0, inf]``. +// +// For real-valued input data types, `arccosh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `arccosh` is a complex analytical function that +// has a branch cut `[-inf, 1]` and is continuous from above on it. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arccosh +// +// Examples +// -------- +// >>> np.arccosh([np.e, 10.0]) +// array([ 1.65745445, 2.99322285]) +// >>> np.arccosh(1) +// 0.0 +// +//go:linkname Arccosh py.arccosh +func Arccosh(__llgo_va_list ...interface{}) *py.Object +// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse sine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// `y`-coordinate on the unit circle. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// The inverse sine of each element in `x`, in radians and in the +// closed interval ``[-pi/2, pi/2]``. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin +// +// Notes +// ----- +// `arcsin` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that :math:`sin(z) = x`. The convention is to +// return the angle `z` whose real part lies in [-pi/2, pi/2]. +// +// For real-valued input data types, *arcsin* always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse sine is also known as `asin` or sin^{-1}. +// +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79ff. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// >>> np.arcsin(1) # pi/2 +// 1.5707963267948966 +// >>> np.arcsin(-1) # -pi/2 +// -1.5707963267948966 +// >>> np.arcsin(0) +// 0.0 +// +//go:linkname Arcsin py.arcsin +func Arcsin(__llgo_va_list ...interface{}) *py.Object +// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic sine element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `arcsinh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `sinh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// +// For real-valued input data types, `arcsinh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// returns ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arcsinh +// +// Examples +// -------- +// >>> np.arcsinh(np.array([np.e, 10.0])) +// array([ 1.72538256, 2.99822295]) +// +//go:linkname Arcsinh py.arcsinh +func Arcsinh(__llgo_va_list ...interface{}) *py.Object +// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric inverse tangent, element-wise. +// +// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. +// +// Parameters +// ---------- +// x : array_like +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Out has the same shape as `x`. Its real part is in +// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) +// and the positive `x`-axis. +// angle : Argument of complex values. +// +// Notes +// ----- +// `arctan` is a multi-valued function: for each `x` there are infinitely +// many numbers `z` such that tan(`z`) = `x`. The convention is to return +// the angle `z` whose real part lies in [-pi/2, pi/2]. +// +// For real-valued input data types, `arctan` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse tangent is also known as `atan` or tan^{-1}. +// +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// +// Examples +// -------- +// We expect the arctan of 0 to be 0, and of 1 to be pi/4: +// +// >>> np.arctan([0, 1]) +// array([ 0. , 0.78539816]) +// +// >>> np.pi/4 +// 0.78539816339744828 +// +// Plot arctan: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-10, 10) +// >>> plt.plot(x, np.arctan(x)) +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Arctan py.arctan +func Arctan(__llgo_va_list ...interface{}) *py.Object +// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. +// +// 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`). (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). +// +// This function is not defined for complex-valued arguments; for the +// so-called argument of complex values, use `angle`. +// +// Parameters +// ---------- +// x1 : array_like, real-valued +// `y`-coordinates. +// x2 : array_like, real-valued +// `x`-coordinates. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// angle : ndarray +// Array of angles in radians, in the range ``[-pi, pi]``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// arctan, tan, angle +// +// Notes +// ----- +// *arctan2* is identical to the `atan2` function of the underlying +// C library. The following special values are defined in the C +// standard: [1]_ +// +// ====== ====== ================ +// `x1` `x2` `arctan2(x1,x2)` +// ====== ====== ================ +// +/- 0 +0 +/- 0 +// +/- 0 -0 +/- pi +// > 0 +/-inf +0 / +pi +// < 0 +/-inf -0 / -pi +// +/-inf +inf +/- (pi/4) +// +/-inf -inf +/- (3*pi/4) +// ====== ====== ================ +// +// Note that +0 and -0 are distinct floating point numbers, as are +inf +// and -inf. +// +// References +// ---------- +// .. [1] ISO/IEC standard 9899:1999, "Programming language C." +// +// Examples +// -------- +// Consider four points in different quadrants: +// +// >>> x = np.array([-1, +1, +1, -1]) +// >>> y = np.array([-1, -1, +1, +1]) +// >>> np.arctan2(y, x) * 180 / np.pi +// array([-135., -45., 45., 135.]) +// +// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 +// and at several other special points, obtaining values in +// the range ``[-pi, pi]``: +// +// >>> np.arctan2([1., -1.], [0., 0.]) +// array([ 1.57079633, -1.57079633]) +// >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) +// array([0. , 3.14159265, 0.78539816]) +// +//go:linkname Arctan2 py.arctan2 +func Arctan2(__llgo_va_list ...interface{}) *py.Object +// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Inverse hyperbolic tangent element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.arctanh +// +// Notes +// ----- +// `arctanh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``tanh(z) = x``. The convention is to return +// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// +// For real-valued input data types, `arctanh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// 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. +// +// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arctanh +// +// Examples +// -------- +// >>> np.arctanh([0, -0.5]) +// array([ 0. , -0.54930614]) +// +//go:linkname Arctanh py.arctanh +func Arctanh(__llgo_va_list ...interface{}) *py.Object +// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise AND of two arrays element-wise. +// +// Computes the bit-wise AND of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``&``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and +// bitwise_or +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise AND of 13 and 17 is +// therefore ``000000001``, or 1: +// +// >>> np.bitwise_and(13, 17) +// 1 +// +// >>> np.bitwise_and(14, 13) +// 12 +// >>> np.binary_repr(12) +// '1100' +// >>> np.bitwise_and([14,3], 13) +// array([12, 1]) +// +// >>> np.bitwise_and([11,7], [4,25]) +// array([0, 1]) +// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) +// array([ 2, 4, 16]) +// >>> np.bitwise_and([True, True], [False, True]) +// array([False, True]) +// +// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([3, 14, 16]) +// >>> x1 & x2 +// array([ 2, 4, 16]) +// +//go:linkname BitwiseAnd py.bitwise_and +func BitwiseAnd(__llgo_va_list ...interface{}) *py.Object +// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise OR of two arrays element-wise. +// +// Computes the bit-wise OR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``|``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or +// bitwise_and +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 has the binary representation ``00001101``. Likewise, +// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is +// then ``00011101``, or 29: +// +// >>> np.bitwise_or(13, 16) +// 29 +// >>> np.binary_repr(29) +// '11101' +// +// >>> np.bitwise_or(32, 2) +// 34 +// >>> np.bitwise_or([33, 4], 1) +// array([33, 5]) +// >>> np.bitwise_or([33, 4], [1, 2]) +// array([33, 6]) +// +// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) +// array([ 6, 5, 255]) +// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) +// array([ 6, 5, 255]) +// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), +// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) +// array([ 6, 5, 255, 2147483647]) +// >>> np.bitwise_or([True, True], [False, True]) +// array([ True, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([4, 4, 4]) +// >>> x1 | x2 +// array([ 6, 5, 255]) +// +//go:linkname BitwiseOr py.bitwise_or +func BitwiseOr(__llgo_va_list ...interface{}) *py.Object +// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise XOR of two arrays element-wise. +// +// Computes the bit-wise XOR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``^``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_xor +// bitwise_and +// bitwise_or +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise XOR of 13 and 17 is +// therefore ``00011100``, or 28: +// +// >>> np.bitwise_xor(13, 17) +// 28 +// >>> np.binary_repr(28) +// '11100' +// +// >>> np.bitwise_xor(31, 5) +// 26 +// >>> np.bitwise_xor([31,3], 5) +// array([26, 6]) +// +// >>> np.bitwise_xor([31,3], [5,6]) +// array([26, 5]) +// >>> np.bitwise_xor([True, True], [False, True]) +// array([ True, False]) +// +// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on +// ndarrays. +// +// >>> x1 = np.array([True, True]) +// >>> x2 = np.array([False, True]) +// >>> x1 ^ x2 +// array([ True, False]) +// +//go:linkname BitwiseXor py.bitwise_xor +func BitwiseXor(__llgo_va_list ...interface{}) *py.Object +// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the cube-root of an array, element-wise. +// +// .. versionadded:: 1.10.0 +// +// Parameters +// ---------- +// x : array_like +// The values whose cube-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the cube +// cube-root of each element in `x`. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. +// +// +// Examples +// -------- +// >>> np.cbrt([1,8,27]) +// array([ 1., 2., 3.]) +// +//go:linkname Cbrt py.cbrt +func Cbrt(__llgo_va_list ...interface{}) *py.Object +// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the ceiling of the input, element-wise. +// +// The ceil of the scalar `x` is the smallest integer `i`, such that +// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The ceiling of each element in `x`, with `float` dtype. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// floor, trunc, rint, fix +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.ceil(a) +// array([-1., -1., -0., 1., 2., 2., 2.]) +// +//go:linkname Ceil py.ceil +func Ceil(__llgo_va_list ...interface{}) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conj py.conj +func Conj(__llgo_va_list ...interface{}) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conjugate py.conjugate +func Conjugate(__llgo_va_list ...interface{}) *py.Object +// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Change the sign of x1 to that of x2, element-wise. +// +// If `x2` is a scalar, its sign will be copied to all elements of `x1`. +// +// Parameters +// ---------- +// x1 : array_like +// Values to change the sign of. +// x2 : array_like +// The sign of `x2` is copied to `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The values of `x1` with the sign of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.copysign(1.3, -1) +// -1.3 +// >>> 1/np.copysign(0, 1) +// inf +// >>> 1/np.copysign(0, -1) +// -inf +// +// >>> np.copysign([-1, 0, 1], -1.1) +// array([-1., -0., -1.]) +// >>> np.copysign([-1, 0, 1], np.arange(3)-1) +// array([-1., 0., 1.]) +// +//go:linkname Copysign py.copysign +func Copysign(__llgo_va_list ...interface{}) *py.Object +// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Cosine element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding cosine values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. +// +// Examples +// -------- +// >>> np.cos(np.array([0, np.pi/2, np.pi])) +// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) +// >>> +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Cos py.cos +func Cos(__llgo_va_list ...interface{}) *py.Object +// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Hyperbolic cosine, element-wise. +// +// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array of same shape as `x`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.cosh(0) +// 1.0 +// +// The hyperbolic cosine describes the shape of a hanging cable: +// +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-4, 4, 1000) +// >>> plt.plot(x, np.cosh(x)) +// >>> plt.show() +// +//go:linkname Cosh py.cosh +func Cosh(__llgo_va_list ...interface{}) *py.Object +// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Angles in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in radians. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : Convert angles from radians to degrees. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// ``deg2rad(x)`` is ``x * pi / 180``. +// +// Examples +// -------- +// >>> np.deg2rad(180) +// 3.1415926535897931 +// +//go:linkname Deg2rad py.deg2rad +func Deg2rad(__llgo_va_list ...interface{}) *py.Object +// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. +// +// Parameters +// ---------- +// x : array_like +// Input array in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray of floats +// The corresponding degree values; if `out` was supplied this is a +// reference to it. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : equivalent function +// +// Examples +// -------- +// Convert a radian array to degrees +// +// >>> rad = np.arange(12.)*np.pi/6 +// >>> np.degrees(rad) +// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., +// 270., 300., 330.]) +// +// >>> out = np.zeros((rad.shape)) +// >>> r = np.degrees(rad, out) +// >>> np.all(r == out) +// True +// +//go:linkname Degrees py.degrees +func Degrees(__llgo_va_list ...interface{}) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. +// +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. +// +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.divide(x1, x2) +// array([[nan, 1. , 1. ], +// [inf, 4. , 2.5], +// [inf, 7. , 4. ]]) +// +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) +// +//go:linkname Divide py.divide +func Divide(__llgo_va_list ...interface{}) *py.Object +// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return element-wise quotient and remainder simultaneously. +// +// .. versionadded:: 1.13.0 +// +// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster +// because it avoids redundant work. It is used to implement the Python +// built-in function ``divmod`` on NumPy arrays. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out1 : ndarray +// Element-wise quotient resulting from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// out2 : ndarray +// Element-wise remainder from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent to Python's ``//`` operator. +// remainder : Equivalent to Python's ``%`` operator. +// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return +// values switched. +// +// Examples +// -------- +// >>> np.divmod(np.arange(5), 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// +// The `divmod` function can be used as a shorthand for ``np.divmod`` on +// ndarrays. +// +// >>> x = np.arange(5) +// >>> divmod(x, 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// +//go:linkname Divmod py.divmod +func Divmod(__llgo_va_list ...interface{}) *py.Object +// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return (x1 == x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// not_equal, greater_equal, less_equal, greater, less +// +// Examples +// -------- +// >>> np.equal([0, 1, 3], np.arange(3)) +// array([ True, True, False]) +// +// What is compared are values, not types. So an int (1) and an array of +// length one can evaluate as True: +// +// >>> np.equal(1, np.ones(1)) +// array([ True]) +// +// The ``==`` operator can be used as a shorthand for ``np.equal`` on +// ndarrays. +// +// >>> a = np.array([2, 4, 6]) +// >>> b = np.array([2, 4, 2]) +// >>> a == b +// array([ True, True, False]) +// +//go:linkname Equal py.equal +func Equal(__llgo_va_list ...interface{}) *py.Object +// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the exponential of all elements in the input array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array, element-wise exponential of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. +// exp2 : Calculate ``2**x`` for all elements in the array. +// +// Notes +// ----- +// The irrational number ``e`` is also known as Euler's number. It is +// approximately 2.718281, and is the base of the natural logarithm, +// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, +// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. +// +// For complex arguments, ``x = a + ib``, we can write +// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already +// known (it is the real argument, described above). The second term, +// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with +// magnitude 1 and a periodic phase. +// +// References +// ---------- +// .. [1] Wikipedia, "Exponential function", +// https://en.wikipedia.org/wiki/Exponential_function +// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions +// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, +// https://personal.math.ubc.ca/~cbm/aands/page_69.htm +// +// Examples +// -------- +// Plot the magnitude and phase of ``exp(x)`` in the complex plane: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) +// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane +// >>> out = np.exp(xx) +// +// >>> plt.subplot(121) +// >>> plt.imshow(np.abs(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') +// >>> plt.title('Magnitude of exp(x)') +// +// >>> plt.subplot(122) +// >>> plt.imshow(np.angle(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') +// >>> plt.title('Phase (angle) of exp(x)') +// >>> plt.show() +// +//go:linkname Exp py.exp +func Exp(__llgo_va_list ...interface{}) *py.Object +// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate `2**p` for all `p` in the input array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise 2 to the power `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// power +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// +// +// Examples +// -------- +// >>> np.exp2([2, 3]) +// array([ 4., 8.]) +// +//go:linkname Exp2 py.exp2 +func Exp2(__llgo_va_list ...interface{}) *py.Object +// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate ``exp(x) - 1`` for all elements in the array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise exponential minus one: ``out = exp(x) - 1``. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log1p : ``log(1 + x)``, the inverse of expm1. +// +// +// Notes +// ----- +// This function provides greater precision than ``exp(x) - 1`` +// for small values of ``x``. +// +// Examples +// -------- +// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to +// about 32 significant digits. This example shows the superiority of +// expm1 in this case. +// +// >>> np.expm1(1e-10) +// 1.00000000005e-10 +// >>> np.exp(1e-10) - 1 +// 1.000000082740371e-10 +// +//go:linkname Expm1 py.expm1 +func Expm1(__llgo_va_list ...interface{}) *py.Object +// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the absolute values element-wise. +// +// This function returns the absolute values (positive magnitude) of the +// data in `x`. Complex values are not handled, use `absolute` to find the +// absolute values of complex data. +// +// Parameters +// ---------- +// x : array_like +// The array of numbers for which the absolute values are required. If +// `x` is a scalar, the result `y` will also be a scalar. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The absolute values of `x`, the returned values are always floats. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// absolute : Absolute values including `complex` types. +// +// Examples +// -------- +// >>> np.fabs(-1) +// 1.0 +// >>> np.fabs([-1.2, 1.2]) +// array([ 1.2, 1.2]) +// +//go:linkname Fabs py.fabs +func Fabs(__llgo_va_list ...interface{}) *py.Object +// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the floor of the input, element-wise. +// +// The floor of the scalar `x` is the largest integer `i`, such that +// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The floor of each element in `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ceil, trunc, rint, fix +// +// Notes +// ----- +// Some spreadsheet programs calculate the "floor-towards-zero", where +// ``floor(-2.5) == -2``. NumPy instead uses the definition of +// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" +// function is called ``fix`` in NumPy. +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.floor(a) +// array([-2., -2., -1., 0., 1., 1., 2.]) +// +//go:linkname Floor py.floor +func Floor(__llgo_va_list ...interface{}) *py.Object +// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the largest integer smaller or equal to the division of the inputs. +// It is equivalent to the Python ``//`` operator and pairs with the +// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` +// up to roundoff. +// +// Parameters +// ---------- +// x1 : array_like +// Numerator. +// x2 : array_like +// Denominator. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// y = floor(`x1`/`x2`) +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// remainder : Remainder complementary to floor_divide. +// divmod : Simultaneous floor division and remainder. +// divide : Standard division. +// floor : Round a number to the nearest integer toward minus infinity. +// ceil : Round a number to the nearest integer toward infinity. +// +// Examples +// -------- +// >>> np.floor_divide(7,3) +// 2 +// >>> np.floor_divide([1., 2., 3., 4.], 2.5) +// array([ 0., 0., 1., 1.]) +// +// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` +// on ndarrays. +// +// >>> x1 = np.array([1., 2., 3., 4.]) +// >>> x1 // 2.5 +// array([0., 0., 1., 1.]) +// +//go:linkname FloorDivide py.floor_divide +func FloorDivide(__llgo_va_list ...interface{}) *py.Object +// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// First array elements raised to powers from second array, element-wise. +// +// Raise each base in `x1` to the positionally-corresponding power in `x2`. +// `x1` and `x2` must be broadcastable to the same shape. This differs from +// the power function in that integers, float16, and float32 are promoted to +// floats with a minimum precision of float64 so that the result is always +// inexact. The intent is that the function will return a usable result for +// negative powers and seldom overflow for positive powers. +// +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). +// +// .. versionadded:: 1.12.0 +// +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// power : power function that preserves type +// +// Examples +// -------- +// Cube each element in a list. +// +// >>> x1 = range(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.float_power(x1, 3) +// array([ 0., 1., 8., 27., 64., 125.]) +// +// Raise the bases to different exponents. +// +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.float_power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) +// +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.float_power(x1, x2) +// array([[ 0., 1., 8., 27., 16., 5.], +// [ 0., 1., 8., 27., 16., 5.]]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1, -4]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.float_power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.float_power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname FloatPower py.float_power +func FloatPower(__llgo_va_list ...interface{}) *py.Object +// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise maximum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// minimum, amin, nanmin +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// +// Examples +// -------- +// >>> np.fmax([2, 3, 4], [1, 5, 2]) +// array([ 2., 5., 4.]) +// +// >>> np.fmax(np.eye(2), [0.5, 2]) +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) +// +//go:linkname Fmax py.fmax +func Fmax(__llgo_va_list ...interface{}) *py.Object +// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise minimum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// maximum, amax, nanmax +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// +// Examples +// -------- +// >>> np.fmin([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) +// +// >>> np.fmin(np.eye(2), [0.5, 2]) +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) +// +// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) +// +//go:linkname Fmin py.fmin +func Fmin(__llgo_va_list ...interface{}) *py.Object +// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// This is the NumPy implementation of the C library function fmod, the +// remainder has the same sign as the dividend `x1`. It is equivalent to +// the Matlab(TM) ``rem`` function and should not be confused with the +// Python modulus operator ``x1 % x2``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend. +// x2 : array_like +// Divisor. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : array_like +// The remainder of the division of `x1` by `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// remainder : Equivalent to the Python ``%`` operator. +// divide +// +// Notes +// ----- +// The result of the modulo operation for negative dividend and divisors +// is bound by conventions. For `fmod`, the sign of result is the sign of +// the dividend, while for `remainder` the sign of the result is the sign +// of the divisor. The `fmod` function is equivalent to the Matlab(TM) +// ``rem`` function. +// +// Examples +// -------- +// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) +// array([-1, 0, -1, 1, 0, 1]) +// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) +// array([1, 0, 1, 1, 0, 1]) +// +// >>> np.fmod([5, 3], [2, 2.]) +// array([ 1., 1.]) +// >>> a = np.arange(-3, 3).reshape(3, 2) +// >>> a +// array([[-3, -2], +// [-1, 0], +// [ 1, 2]]) +// >>> np.fmod(a, [2,2]) +// array([[-1, 0], +// [-1, 0], +// [ 1, 0]]) +// +//go:linkname Fmod py.fmod +func Fmod(__llgo_va_list ...interface{}) *py.Object +// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Decompose the elements of x into mantissa and twos exponent. +// +// Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``. +// The mantissa lies in the open interval(-1, 1), while the twos +// exponent is a signed integer. +// +// Parameters +// ---------- +// x : array_like +// Array of numbers to be decomposed. +// out1 : ndarray, optional +// Output array for the mantissa. Must have the same shape as `x`. +// out2 : ndarray, optional +// Output array for the exponent. Must have the same shape as `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// mantissa : ndarray +// Floating values between -1 and 1. +// This is a scalar if `x` is a scalar. +// exponent : ndarray +// Integer exponents of 2. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`. +// +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. +// +// Examples +// -------- +// >>> x = np.arange(9) +// >>> y1, y2 = np.frexp(x) +// >>> y1 +// array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, +// 0.5 ]) +// >>> y2 +// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) +// >>> y1 * 2**y2 +// array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) +// +//go:linkname Frexp py.frexp +func Frexp(__llgo_va_list ...interface{}) *py.Object +// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the Heaviside step function. +// +// The Heaviside step function is defined as:: +// +// 0 if x1 < 0 +// heaviside(x1, x2) = x2 if x1 == 0 +// 1 if x1 > 0 +// +// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. +// +// Parameters +// ---------- +// x1 : array_like +// Input values. +// x2 : array_like +// The value of the function when x1 is 0. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The output array, element-wise Heaviside step function of `x1`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// .. versionadded:: 1.13.0 +// +// References +// ---------- +// .. Wikipedia, "Heaviside step function", +// https://en.wikipedia.org/wiki/Heaviside_step_function +// +// Examples +// -------- +// >>> np.heaviside([-1.5, 0, 2.0], 0.5) +// array([ 0. , 0.5, 1. ]) +// >>> np.heaviside([-1.5, 0, 2.0], 1) +// array([ 0., 1., 1.]) +// +//go:linkname Heaviside py.heaviside +func Heaviside(__llgo_va_list ...interface{}) *py.Object +// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Given the "legs" of a right triangle, return its hypotenuse. +// +// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. 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. +// (See Examples) +// +// Parameters +// ---------- +// x1, x2 : array_like +// Leg of the triangle(s). +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// z : ndarray +// The hypotenuse of the triangle(s). +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) +// +// Example showing broadcast of scalar_like argument: +// +// >>> np.hypot(3*np.ones((3, 3)), [4]) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) +// +//go:linkname Hypot py.hypot +func Hypot(__llgo_va_list ...interface{}) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. +// +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: +// +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' +// +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) +// +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) +// +//go:linkname Invert py.invert +func Invert(__llgo_va_list ...interface{}) *py.Object +// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for finiteness (not infinity and not Not a Number). +// +// The result is returned as a boolean array. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray, bool +// True where ``x`` is not positive infinity, negative infinity, +// or NaN; false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isinf, isneginf, isposinf, isnan +// +// 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. +// +// Examples +// -------- +// >>> np.isfinite(1) +// True +// >>> np.isfinite(0) +// True +// >>> np.isfinite(np.nan) +// False +// >>> np.isfinite(np.inf) +// False +// >>> np.isfinite(np.NINF) +// False +// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) +// array([False, True, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isfinite(x, y) +// array([0, 1, 0]) +// >>> y +// array([0, 1, 0]) +// +//go:linkname Isfinite py.isfinite +func Isfinite(__llgo_va_list ...interface{}) *py.Object +// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for positive or negative infinity. +// +// Returns a boolean array of the same shape as `x`, True where ``x == +// +/-inf``, otherwise False. +// +// Parameters +// ---------- +// x : array_like +// Input values +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool (scalar) or boolean ndarray +// True where ``x`` is positive or negative infinity, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isneginf, isposinf, isnan, isfinite +// +// 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. +// +// Examples +// -------- +// >>> np.isinf(np.inf) +// True +// >>> np.isinf(np.nan) +// False +// >>> np.isinf(np.NINF) +// True +// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) +// array([ True, True, False, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isinf(x, y) +// array([1, 0, 1]) +// >>> y +// array([1, 0, 1]) +// +//go:linkname Isinf py.isinf +func Isinf(__llgo_va_list ...interface{}) *py.Object +// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for NaN and return result as a boolean array. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaN, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isinf, isneginf, isposinf, isfinite, isnat +// +// 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. +// +// Examples +// -------- +// >>> np.isnan(np.nan) +// True +// >>> np.isnan(np.inf) +// False +// >>> np.isnan([np.log(-1.),1.,np.log(0)]) +// array([ True, False, False]) +// +//go:linkname Isnan py.isnan +func Isnan(__llgo_va_list ...interface{}) *py.Object +// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Test element-wise for NaT (not a time) and return result as a boolean array. +// +// .. versionadded:: 1.13.0 +// +// Parameters +// ---------- +// x : array_like +// Input array with datetime or timedelta data type. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaT, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isnan, isinf, isneginf, isposinf, isfinite +// +// Examples +// -------- +// >>> np.isnat(np.datetime64("NaT")) +// True +// >>> np.isnat(np.datetime64("2016-01-01")) +// False +// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) +// array([ True, False]) +// +//go:linkname Isnat py.isnat +func Isnat(__llgo_va_list ...interface{}) *py.Object +// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` +// +// Parameters +// ---------- +// x1, x2 : array_like, int +// Arrays of values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// +// Returns +// ------- +// y : ndarray or scalar +// The lowest common multiple of the absolute value of the inputs +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// gcd : The greatest common divisor +// +// Examples +// -------- +// >>> np.lcm(12, 20) +// 60 +// >>> np.lcm.reduce([3, 12, 20]) +// 60 +// >>> np.lcm.reduce([40, 12, 20]) +// 120 +// >>> np.lcm(np.arange(6), 20) +// array([ 0, 20, 20, 60, 20, 20]) +// +//go:linkname Lcm py.lcm +func Lcm(__llgo_va_list ...interface{}) *py.Object +// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns x1 * 2**x2, element-wise. +// +// The mantissas `x1` and twos exponents `x2` are used to construct +// floating point numbers ``x1 * 2**x2``. +// +// Parameters +// ---------- +// x1 : array_like +// Array of multipliers. +// x2 : array_like, int +// Array of twos exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The result of ``x1 * 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. +// +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. +// +// `ldexp` is useful as the inverse of `frexp`, if used by itself it is +// more clear to simply use the expression ``x1 * 2**x2``. +// +// Examples +// -------- +// >>> np.ldexp(5, np.arange(4)) +// array([ 5., 10., 20., 40.], dtype=float16) +// +// >>> x = np.arange(6) +// >>> np.ldexp(*np.frexp(x)) +// array([ 0., 1., 2., 3., 4., 5.]) +// +//go:linkname Ldexp py.ldexp +func Ldexp(__llgo_va_list ...interface{}) *py.Object +// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Shift the bits of an integer to the left. +// +// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. +// Since the internal representation of numbers is in binary format, this +// operation is equivalent to multiplying `x1` by ``2**x2``. +// +// Parameters +// ---------- +// x1 : array_like of integer type +// Input values. +// x2 : array_like of integer type +// Number of zeros to append to `x1`. Has to be non-negative. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : array of integer type +// Return `x1` with bits shifted `x2` times to the left. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// right_shift : Shift the bits of an integer to the right. +// binary_repr : Return the binary representation of the input number +// as a string. +// +// Examples +// -------- +// >>> np.binary_repr(5) +// '101' +// >>> np.left_shift(5, 2) +// 20 +// >>> np.binary_repr(20) +// '10100' +// +// >>> np.left_shift(5, [1,2,3]) +// array([10, 20, 40]) +// +// Note that the dtype of the second argument may change the dtype of the +// result and can lead to unexpected results in some cases (see +// :ref:`Casting Rules `): +// +// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 +// >>> print(a, type(a)) # Unexpected result due to upcasting +// 510 +// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) +// >>> print(b, type(b)) +// 254 +// +// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on +// ndarrays. +// +// >>> x1 = 5 +// >>> x2 = np.array([1, 2, 3]) +// >>> x1 << x2 +// array([10, 20, 40]) +// +//go:linkname LeftShift py.left_shift +func LeftShift(__llgo_va_list ...interface{}) *py.Object +// less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 < x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// greater, less_equal, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less([1, 2], [2, 2]) +// array([ True, False]) +// +// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. +// +// >>> a = np.array([1, 2]) +// >>> b = np.array([2, 2]) +// >>> a < b +// array([ True, False]) +// +//go:linkname Less py.less +func Less(__llgo_va_list ...interface{}) *py.Object +// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truth value of (x1 <= x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// greater, less, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less_equal([4, 2, 1], [2, 2, 2]) +// array([False, True, True]) +// +// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on +// ndarrays. +// +// >>> a = np.array([4, 2, 1]) +// >>> b = np.array([2, 2, 2]) +// >>> a <= b +// array([False, True, True]) +// +//go:linkname LessEqual py.less_equal +func LessEqual(__llgo_va_list ...interface{}) *py.Object +// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Natural logarithm, element-wise. +// +// The natural logarithm `log` is the inverse of the exponential function, +// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base +// `e`. +// +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The natural logarithm of `x`, element-wise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log10, log2, log1p, emath.log +// +// Notes +// ----- +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log` always returns real output. For +// each value that cannot be expressed as a real number or infinity, it +// yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log([1, np.e, np.e**2, 0]) +// array([ 0., 1., 2., -Inf]) +// +//go:linkname Log py.log +func Log(__llgo_va_list ...interface{}) *py.Object +// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the base 10 logarithm of the input array, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The logarithm to the base 10 of `x`, element-wise. NaNs are +// returned where x is negative. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.log10 +// +// Notes +// ----- +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `10**z = x`. The convention is to return the +// `z` whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log10` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log10` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. +// `log10` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log10([1e-15, -3.]) +// array([-15., nan]) +// +//go:linkname Log10 py.log10 +func Log10(__llgo_va_list ...interface{}) *py.Object +// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the natural logarithm of one plus the input array, element-wise. +// +// Calculates ``log(1 + x)``. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Natural logarithm of `1 + x`, element-wise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// expm1 : ``exp(x) - 1``, the inverse of `log1p`. +// +// Notes +// ----- +// For real-valued input, `log1p` is accurate also for `x` so small +// that `1 + x == 1` in floating-point accuracy. +// +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = 1 + x`. The convention is to return +// the `z` whose imaginary part lies in `[-pi, pi]`. +// +// For real-valued input data types, `log1p` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log1p` is a complex analytical function that +// has a branch cut `[-inf, -1]` and is continuous from above on it. +// `log1p` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. +// +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm +// +// Examples +// -------- +// >>> np.log1p(1e-99) +// 1e-99 +// >>> np.log(1 + 1e-99) +// 0.0 +// +//go:linkname Log1p py.log1p +func Log1p(__llgo_va_list ...interface{}) *py.Object +// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Base-2 logarithm of `x`. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Base-2 logarithm of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// log, log10, log1p, emath.log2 +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `2**z = x`. The convention is to return the `z` +// whose imaginary part lies in `(-pi, pi]`. +// +// For real-valued input data types, `log2` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. +// +// For complex-valued input, `log2` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. +// +// In the cases where the input has a negative real part and a very small +// negative complex part (approaching 0), the result is so close to `-pi` +// that it evaluates to exactly `-pi`. +// +// Examples +// -------- +// >>> x = np.array([0, 1, 2, 2**4]) +// >>> np.log2(x) +// array([-Inf, 0., 1., 4.]) +// +// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) +// >>> np.log2(xi) +// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) +// +//go:linkname Log2 py.log2 +func Log2(__llgo_va_list ...interface{}) *py.Object +// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Logarithm of the sum of exponentiations of the inputs. +// +// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in +// statistics where the calculated probabilities of events may be so small +// as to exceed the range of normal floating point numbers. In such cases +// the logarithm of the calculated probability is stored. This function +// allows adding probabilities stored in such a fashion. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray +// Logarithm of ``exp(x1) + exp(x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> prob1 = np.log(1e-50) +// >>> prob2 = np.log(2.5e-50) +// >>> prob12 = np.logaddexp(prob1, prob2) +// >>> prob12 +// -113.87649168120691 +// >>> np.exp(prob12) +// 3.5000000000000057e-50 +// +//go:linkname Logaddexp py.logaddexp +func Logaddexp(__llgo_va_list ...interface{}) *py.Object +// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Logarithm of the sum of exponentiations of the inputs in base-2. +// +// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine +// learning when the calculated probabilities of events may be so small as +// to exceed the range of normal floating point numbers. In such cases +// the base-2 logarithm of the calculated probability can be used instead. +// This function allows adding probabilities stored in such a fashion. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray +// Base-2 logarithm of ``2**x1 + 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logaddexp: Logarithm of the sum of exponentiations of the inputs. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> prob1 = np.log2(1e-50) +// >>> prob2 = np.log2(2.5e-50) +// >>> prob12 = np.logaddexp2(prob1, prob2) +// >>> prob1, prob2, prob12 +// (-166.09640474436813, -164.77447664948076, -164.28904982231052) +// >>> 2**prob12 +// 3.4999999999999914e-50 +// +//go:linkname Logaddexp2 py.logaddexp2 +func Logaddexp2(__llgo_va_list ...interface{}) *py.Object +// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 AND x2 element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// Boolean result of the logical AND operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or, logical_not, logical_xor +// bitwise_and +// +// Examples +// -------- +// >>> np.logical_and(True, False) +// False +// >>> np.logical_and([True, False], [False, False]) +// array([False, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_and(x>1, x<4) +// array([False, False, True, True, False]) +// +// +// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on +// boolean ndarrays. +// +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a & b +// array([False, False]) +// +//go:linkname LogicalAnd py.logical_and +func LogicalAnd(__llgo_va_list ...interface{}) *py.Object +// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of NOT x element-wise. +// +// Parameters +// ---------- +// x : array_like +// Logical NOT is applied to the elements of `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool or ndarray of bool +// 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. +// +// See Also +// -------- +// logical_and, logical_or, logical_xor +// +// Examples +// -------- +// >>> np.logical_not(3) +// False +// >>> np.logical_not([True, False, 0, 1]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_not(x<3) +// array([False, False, False, True, True]) +// +//go:linkname LogicalNot py.logical_not +func LogicalNot(__llgo_va_list ...interface{}) *py.Object +// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 OR x2 element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Logical OR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or bool +// Boolean result of the logical OR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and, logical_not, logical_xor +// bitwise_or +// +// Examples +// -------- +// >>> np.logical_or(True, False) +// True +// >>> np.logical_or([True, False], [False, False]) +// array([ True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_or(x < 1, x > 3) +// array([ True, False, False, False, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on +// boolean ndarrays. +// +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a | b +// array([ True, False]) +// +//go:linkname LogicalOr py.logical_or +func LogicalOr(__llgo_va_list ...interface{}) *py.Object +// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the truth value of x1 XOR x2, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Logical XOR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : bool or ndarray of bool +// Boolean result of the logical XOR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_and, logical_or, logical_not, bitwise_xor +// +// Examples +// -------- +// >>> np.logical_xor(True, False) +// True +// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_xor(x < 1, x > 3) +// array([ True, False, False, False, True]) +// +// Simple example showing support of broadcasting +// +// >>> np.logical_xor(0, np.eye(2)) +// array([[ True, False], +// [False, True]]) +// +//go:linkname LogicalXor py.logical_xor +func LogicalXor(__llgo_va_list ...interface{}) *py.Object +// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise maximum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// fmin, amin, nanmin +// +// Notes +// ----- +// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when +// neither x1 nor x2 are nans, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.maximum([2, 3, 4], [1, 5, 2]) +// array([2, 5, 4]) +// +// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.maximum(np.Inf, 1) +// inf +// +//go:linkname Maximum py.maximum +func Maximum(__llgo_va_list ...interface{}) *py.Object +// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Element-wise minimum of array elements. +// +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// fmax, amax, nanmax +// +// Notes +// ----- +// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when +// neither x1 nor x2 are NaNs, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.minimum([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) +// +// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) +// +// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.minimum(-np.Inf, 1) +// -inf +// +//go:linkname Minimum py.minimum +func Minimum(__llgo_va_list ...interface{}) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. +// +// .. warning:: +// +// This should not be confused with: +// +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor +// +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. +// +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) +// +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Mod py.mod +func Mod(__llgo_va_list ...interface{}) *py.Object +// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the fractional and integral parts of an array, element-wise. +// +// The fractional and integral parts are negative if the given number is +// negative. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y1 : ndarray +// Fractional part of `x`. +// This is a scalar if `x` is a scalar. +// y2 : ndarray +// Integral part of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// For integer input the return values are floats. +// +// See Also +// -------- +// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values +// switched, except it always has a positive remainder. +// +// Examples +// -------- +// >>> np.modf([0, 3.5]) +// (array([ 0. , 0.5]), array([ 0., 3.])) +// >>> np.modf(-0.5) +// (-0.5, -0) +// +//go:linkname Modf py.modf +func Modf(__llgo_va_list ...interface{}) *py.Object +// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Multiply arguments element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays to be multiplied. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The product of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to `x1` * `x2` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.multiply(2.0, 4.0) +// 8.0 +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.multiply(x1, x2) +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) +// +// The ``*`` operator can be used as a shorthand for ``np.multiply`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 * x2 +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) +// +//go:linkname Multiply py.multiply +func Multiply(__llgo_va_list ...interface{}) *py.Object +// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Numerical negative, element-wise. +// +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = -x`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.negative([1.,-1.]) +// array([-1., 1.]) +// +// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on +// ndarrays. +// +// >>> x1 = np.array(([1., -1.])) +// >>> -x1 +// array([-1., 1.]) +// +//go:linkname Negative py.negative +func Negative(__llgo_va_list ...interface{}) *py.Object +// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the next floating-point value after x1 towards x2, element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Values to find the next representable value of. +// x2 : array_like +// The direction where to look for the next representable value of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The next representable values of `x1` in the direction of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> eps = np.finfo(np.float64).eps +// >>> np.nextafter(1, 2) == eps + 1 +// True +// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] +// array([ True, True]) +// +//go:linkname Nextafter py.nextafter +func Nextafter(__llgo_va_list ...interface{}) *py.Object +// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return (x1 != x2) element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// 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. +// +// See Also +// -------- +// equal, greater, greater_equal, less, less_equal +// +// Examples +// -------- +// >>> np.not_equal([1.,2.], [1., 3.]) +// array([False, True]) +// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) +// array([[False, True], +// [False, True]]) +// +// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on +// ndarrays. +// +// >>> a = np.array([1., 2.]) +// >>> b = np.array([1., 3.]) +// >>> a != b +// array([False, True]) +// +//go:linkname NotEqual py.not_equal +func NotEqual(__llgo_va_list ...interface{}) *py.Object +// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Numerical positive, element-wise. +// +// .. versionadded:: 1.13.0 +// +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = +x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// Equivalent to `x.copy()`, but only defined for types that support +// arithmetic. +// +// Examples +// -------- +// +// >>> x1 = np.array(([1., -1.])) +// >>> np.positive(x1) +// array([ 1., -1.]) +// +// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on +// ndarrays. +// +// >>> x1 = np.array(([1., -1.])) +// >>> +x1 +// array([ 1., -1.]) +// +//go:linkname Positive py.positive +func Positive(__llgo_va_list ...interface{}) *py.Object +// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// First array elements raised to powers from second array, element-wise. +// +// Raise each base in `x1` to the positionally-corresponding power in +// `x2`. `x1` and `x2` must be broadcastable to the same shape. +// +// An integer type raised to a negative integer power will raise a +// ``ValueError``. +// +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). +// +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// float_power : power function that promotes integers to float +// +// Examples +// -------- +// Cube each element in an array. +// +// >>> x1 = np.arange(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.power(x1, 3) +// array([ 0, 1, 8, 27, 64, 125]) +// +// Raise the bases to different exponents. +// +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) +// +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.power(x1, x2) +// array([[ 0, 1, 8, 27, 16, 5], +// [ 0, 1, 8, 27, 16, 5]]) +// +// The ``**`` operator can be used as a shorthand for ``np.power`` on +// ndarrays. +// +// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) +// >>> x1 = np.arange(6) +// >>> x1 ** x2 +// array([ 0, 1, 8, 27, 16, 5]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1.0, -4.0]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname Power py.power +func Power(__llgo_va_list ...interface{}) *py.Object +// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. +// +// Parameters +// ---------- +// x : array_like +// Angle in radians. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in degrees. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// deg2rad : Convert angles from degrees to radians. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// rad2deg(x) is ``180 * x / pi``. +// +// Examples +// -------- +// >>> np.rad2deg(np.pi/2) +// 90.0 +// +//go:linkname Rad2deg py.rad2deg +func Rad2deg(__llgo_va_list ...interface{}) *py.Object +// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Input array in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding radian values. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// deg2rad : equivalent function +// +// Examples +// -------- +// Convert a degree array to radians +// +// >>> deg = np.arange(12.) * 30. +// >>> np.radians(deg) +// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , +// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, +// 5.23598776, 5.75958653]) +// +// >>> out = np.zeros((deg.shape)) +// >>> ret = np.radians(deg, out) +// >>> ret is out +// True +// +//go:linkname Radians py.radians +func Radians(__llgo_va_list ...interface{}) *py.Object +// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the reciprocal of the argument, element-wise. +// +// Calculates ``1/x``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// Return array. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// .. note:: +// This function is not designed to work with integers. +// +// For integer arguments with absolute value larger than 1 the result is +// always zero because of the way Python handles integer division. For +// integer zero the result is an overflow. +// +// Examples +// -------- +// >>> np.reciprocal(2.) +// 0.5 +// >>> np.reciprocal([1, 2., 3.33]) +// array([ 1. , 0.5 , 0.3003003]) +// +//go:linkname Reciprocal py.reciprocal +func Reciprocal(__llgo_va_list ...interface{}) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. +// +// .. warning:: +// +// This should not be confused with: +// +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor +// +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. +// +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) +// +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Remainder py.remainder +func Remainder(__llgo_va_list ...interface{}) *py.Object +// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Shift the bits of an integer to the right. +// +// Bits are shifted to the right `x2`. Because the internal +// representation of numbers is in binary format, this operation is +// equivalent to dividing `x1` by ``2**x2``. +// +// Parameters +// ---------- +// x1 : array_like, int +// Input values. +// x2 : array_like, int +// Number of bits to remove at the right of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray, int +// Return `x1` with bits shifted `x2` times to the right. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// left_shift : Shift the bits of an integer to the left. +// binary_repr : Return the binary representation of the input number +// as a string. +// +// Examples +// -------- +// >>> np.binary_repr(10) +// '1010' +// >>> np.right_shift(10, 1) +// 5 +// >>> np.binary_repr(5) +// '101' +// +// >>> np.right_shift(10, [1,2,3]) +// array([5, 2, 1]) +// +// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on +// ndarrays. +// +// >>> x1 = 10 +// >>> x2 = np.array([1,2,3]) +// >>> x1 >> x2 +// array([5, 2, 1]) +// +//go:linkname RightShift py.right_shift +func RightShift(__llgo_va_list ...interface{}) *py.Object +// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Round elements of the array to the nearest integer. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Output array is same shape and type as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// fix, ceil, floor, trunc +// +// Notes +// ----- +// For values exactly halfway between rounded decimal values, NumPy +// rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, +// -0.5 and 0.5 round to 0.0, etc. +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.rint(a) +// array([-2., -2., -0., 0., 2., 2., 2.]) +// +//go:linkname Rint py.rint +func Rint(__llgo_va_list ...interface{}) *py.Object +// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns an element-wise indication of the sign of a number. +// +// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan +// is returned for nan inputs. +// +// For complex inputs, the `sign` function returns +// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. +// +// complex(nan, 0) is returned for complex nan inputs. +// +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The sign of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// There is more than one definition of sign in common use for complex +// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` +// which is different from a common alternative, :math:`x/|x|`. +// +// Examples +// -------- +// >>> np.sign([-5., 4.5]) +// array([-1., 1.]) +// >>> np.sign(0) +// 0 +// >>> np.sign(5-2j) +// (1+0j) +// +//go:linkname Sign py.sign +func Sign(__llgo_va_list ...interface{}) *py.Object +// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns element-wise True where signbit is set (less than zero). +// +// Parameters +// ---------- +// x : array_like +// The input value(s). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// result : ndarray of bool +// Output array, or reference to `out` if that was supplied. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> np.signbit(-1.2) +// True +// >>> np.signbit(np.array([1, -2.3, 2.1])) +// array([False, True, False]) +// +//go:linkname Signbit py.signbit +func Signbit(__llgo_va_list ...interface{}) *py.Object +// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Trigonometric sine, element-wise. +// +// Parameters +// ---------- +// x : array_like +// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : array_like +// The sine of each element of x. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// arcsin, sinh, cos +// +// Notes +// ----- +// The sine is one of the fundamental functions of trigonometry (the +// mathematical study of triangles). Consider a circle of radius 1 +// centered on the origin. A ray comes in from the :math:`+x` axis, makes +// an angle at the origin (measured counter-clockwise from that axis), and +// departs from the origin. The :math:`y` coordinate of the outgoing +// ray's intersection with the unit circle is the sine of that angle. It +// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The +// function has zeroes where the angle is a multiple of :math:`\pi`. +// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. +// The numerous properties of the sine and related functions are included +// in any standard trigonometry text. +// +// Examples +// -------- +// Print sine of one angle: +// +// >>> np.sin(np.pi/2.) +// 1.0 +// +// Print sines of an array of angles given in degrees: +// +// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) +// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) +// +// Plot the sine function: +// +// >>> import matplotlib.pylab as plt +// >>> x = np.linspace(-np.pi, np.pi, 201) +// >>> plt.plot(x, np.sin(x)) +// >>> plt.xlabel('Angle [rad]') +// >>> plt.ylabel('sin(x)') +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Sin py.sin +func Sin(__llgo_va_list ...interface{}) *py.Object +// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Hyperbolic sine, element-wise. +// +// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or +// ``-1j * np.sin(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding hyperbolic sine values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// +// Examples +// -------- +// >>> np.sinh(0) +// 0.0 +// >>> np.sinh(np.pi*1j/2) +// 1j +// >>> np.sinh(np.pi*1j) # (exact value is 0) +// 1.2246063538223773e-016j +// >>> # Discrepancy due to vagaries of floating point arithmetic. +// +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.sinh([0.1], out1) +// >>> out2 is out1 +// True +// +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Sinh py.sinh +func Sinh(__llgo_va_list ...interface{}) *py.Object +// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the distance between x and the nearest adjacent number. +// +// Parameters +// ---------- +// x : array_like +// Values to find the spacing of. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The spacing of values of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// It can be considered as a generalization of EPS: +// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there +// should not be any representable number between ``x + spacing(x)`` and +// x for any finite x. +// +// Spacing of +- inf and NaN is NaN. +// +// Examples +// -------- +// >>> np.spacing(1) == np.finfo(np.float64).eps +// True +// +//go:linkname Spacing py.spacing +func Spacing(__llgo_va_list ...interface{}) *py.Object +// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the non-negative square-root of an array, element-wise. +// +// Parameters +// ---------- +// x : array_like +// The values whose square-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the positive +// square-root of each element in `x`. If any element in `x` is +// complex, a complex array is returned (and the square-roots of +// negative reals are calculated). If all of the elements in `x` +// are real, so is `y`, with negative elements returning ``nan``. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// emath.sqrt +// A version which returns complex numbers when given negative reals. +// Note that 0.0 and -0.0 are handled differently for complex inputs. +// +// Notes +// ----- +// *sqrt* has--consistent with common convention--as its branch cut the +// real "interval" [`-inf`, 0), and is continuous from above on it. +// A branch cut is a curve in the complex plane across which a given +// complex function fails to be continuous. +// +// Examples +// -------- +// >>> np.sqrt([1,4,9]) +// array([ 1., 2., 3.]) +// +// >>> np.sqrt([4, -1, -3+4J]) +// array([ 2.+0.j, 0.+1.j, 1.+2.j]) +// +// >>> np.sqrt([4, -1, np.inf]) +// array([ 2., nan, inf]) +// +//go:linkname Sqrt py.sqrt +func Sqrt(__llgo_va_list ...interface{}) *py.Object +// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the element-wise square of the input. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Element-wise `x*x`, of the same shape and dtype as `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// numpy.linalg.matrix_power +// sqrt +// power +// +// Examples +// -------- +// >>> np.square([-1j, 1]) +// array([-1.-0.j, 1.+0.j]) +// +//go:linkname Square py.square +func Square(__llgo_va_list ...interface{}) *py.Object +// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Subtract arguments, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays to be subtracted from each other. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The difference of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to ``x1 - x2`` in terms of array broadcasting. +// +// Examples +// -------- +// >>> np.subtract(1.0, 4.0) +// -3.0 +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.subtract(x1, x2) +// array([[ 0., 0., 0.], +// [ 3., 3., 3.], +// [ 6., 6., 6.]]) +// +// The ``-`` operator can be used as a shorthand for ``np.subtract`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 - x2 +// array([[0., 0., 0.], +// [3., 3., 3.], +// [6., 6., 6.]]) +// +//go:linkname Subtract py.subtract +func Subtract(__llgo_va_list ...interface{}) *py.Object +// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute tangent element-wise. +// +// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding tangent values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. +// +// Examples +// -------- +// >>> from math import pi +// >>> np.tan(np.array([-pi,pi/2,pi])) +// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) +// >>> +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Tan py.tan +func Tan(__llgo_va_list ...interface{}) *py.Object +// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute hyperbolic tangent element-wise. +// +// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding hyperbolic tangent values. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// https://personal.math.ubc.ca/~cbm/aands/page_83.htm +// +// .. [2] Wikipedia, "Hyperbolic function", +// https://en.wikipedia.org/wiki/Hyperbolic_function +// +// Examples +// -------- +// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) +// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) +// +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.tanh([0.1], out1) +// >>> out2 is out1 +// True +// +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// +//go:linkname Tanh py.tanh +func Tanh(__llgo_va_list ...interface{}) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. +// +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. +// +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.divide(x1, x2) +// array([[nan, 1. , 1. ], +// [inf, 4. , 2.5], +// [inf, 7. , 4. ]]) +// +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. +// +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) +// +//go:linkname TrueDivide py.true_divide +func TrueDivide(__llgo_va_list ...interface{}) *py.Object +// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truncated value of the input, element-wise. +// +// The truncated value of the scalar `x` is the nearest integer `i` which +// is closer to zero than `x` is. In short, the fractional part of the +// signed number `x` is discarded. +// +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The truncated value of each element in `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// ceil, floor, rint, fix +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.trunc(a) +// array([-1., -1., -0., 0., 1., 1., 2.]) +// +//go:linkname Trunc py.trunc +func Trunc(__llgo_va_list ...interface{}) *py.Object +// +// Return the scalar dtype or NumPy equivalent of Python type of an object. +// +// Parameters +// ---------- +// rep : any +// The object of which the type is returned. +// default : any, optional +// If given, this is returned for objects whose types can not be +// determined. If not given, None is returned for those objects. +// +// Returns +// ------- +// dtype : dtype or Python type +// The data type of `rep`. +// +// See Also +// -------- +// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype +// +// Examples +// -------- +// >>> np.obj2sctype(np.int32) +// +// >>> np.obj2sctype(np.array([1., 2.])) +// +// >>> np.obj2sctype(np.array([1.j])) +// +// +// >>> np.obj2sctype(dict) +// +// >>> np.obj2sctype('string') +// +// >>> np.obj2sctype(1, default=list) +// +// +// +// +//go:linkname Obj2sctype py.obj2sctype +func Obj2sctype(rep *py.Object, default_ *py.Object) *py.Object +// +// Return the string representation of a scalar dtype. +// +// Parameters +// ---------- +// sctype : scalar dtype or object +// If a scalar dtype, the corresponding string character is +// returned. If an object, `sctype2char` tries to infer its scalar type +// and then return the corresponding string character. +// +// Returns +// ------- +// typechar : str +// The string character corresponding to the scalar type. +// +// Raises +// ------ +// ValueError +// If `sctype` is an object for which the type can not be inferred. +// +// See Also +// -------- +// obj2sctype, issctype, issubsctype, mintypecode +// +// Examples +// -------- +// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: +// ... print(np.sctype2char(sctype)) +// l # may vary +// d +// D +// S +// O +// +// >>> x = np.array([1., 2-1.j]) +// >>> np.sctype2char(x) +// 'D' +// >>> np.sctype2char(list) +// 'O' +// +// +// +//go:linkname Sctype2char py.sctype2char +func Sctype2char(sctype *py.Object) *py.Object +// +// Return the scalar type of highest precision of the same kind as the input. +// +// Parameters +// ---------- +// t : dtype or dtype specifier +// The input data type. This can be a `dtype` object or an object that +// is convertible to a `dtype`. +// +// Returns +// ------- +// out : dtype +// The highest precision data type of the same kind (`dtype.kind`) as `t`. +// +// See Also +// -------- +// obj2sctype, mintypecode, sctype2char +// dtype +// +// Examples +// -------- +// >>> np.maximum_sctype(int) +// +// >>> np.maximum_sctype(np.uint8) +// +// >>> np.maximum_sctype(complex) +// # may vary +// +// >>> np.maximum_sctype(str) +// +// +// >>> np.maximum_sctype('i2') +// +// >>> np.maximum_sctype('f4') +// # may vary +// +// +// +//go:linkname MaximumSctype py.maximum_sctype +func MaximumSctype(t *py.Object) *py.Object +// +// Determines whether the given object represents a scalar data-type. +// +// Parameters +// ---------- +// rep : any +// If `rep` is an instance of a scalar dtype, True is returned. If not, +// False is returned. +// +// Returns +// ------- +// out : bool +// Boolean result of check whether `rep` is a scalar dtype. +// +// See Also +// -------- +// issubsctype, issubdtype, obj2sctype, sctype2char +// +// Examples +// -------- +// >>> np.issctype(np.int32) +// True +// >>> np.issctype(list) +// False +// >>> np.issctype(1.1) +// False +// +// Strings are also a scalar type: +// +// >>> np.issctype(np.dtype('str')) +// True +// +// +// +//go:linkname Issctype py.issctype +func Issctype(rep *py.Object) *py.Object +// +// Determine common type following standard coercion rules. +// +// .. deprecated:: NumPy 1.25 +// +// This function is deprecated, use `numpy.promote_types` or +// `numpy.result_type` instead. To achieve semantics for the +// `scalar_types` argument, use `numpy.result_type` and pass the Python +// values `0`, `0.0`, or `0j`. +// This will give the same results in almost all cases. +// More information and rare exception can be found in the +// `NumPy 1.25 release notes `_. +// +// Parameters +// ---------- +// array_types : sequence +// A list of dtypes or dtype convertible objects representing arrays. +// scalar_types : sequence +// A list of dtypes or dtype convertible objects representing scalars. +// +// Returns +// ------- +// datatype : dtype +// The common data type, which is the maximum of `array_types` ignoring +// `scalar_types`, unless the maximum of `scalar_types` is of a +// different kind (`dtype.kind`). If the kind is not understood, then +// None is returned. +// +// See Also +// -------- +// dtype, common_type, can_cast, mintypecode +// +// Examples +// -------- +// >>> np.find_common_type([], [np.int64, np.float32, complex]) +// dtype('complex128') +// >>> np.find_common_type([np.int64, np.float32], []) +// dtype('float64') +// +// The standard casting rules ensure that a scalar cannot up-cast an +// array unless the scalar is of a fundamentally different kind of data +// (i.e. under a different hierarchy in the data type hierarchy) then +// the array: +// +// >>> np.find_common_type([np.float32], [np.int64, np.float64]) +// dtype('float32') +// +// Complex is of a different type, so it up-casts the float in the +// `array_types` argument: +// +// >>> np.find_common_type([np.float32], [complex]) +// dtype('complex128') +// +// Type specifier strings are convertible to dtypes and can therefore +// be used instead of dtypes: +// +// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) +// dtype('complex128') +// +// +// +//go:linkname FindCommonType py.find_common_type +func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object +// +// Returns True if first argument is a typecode lower/equal in type hierarchy. +// +// This is like the builtin :func:`issubclass`, but for `dtype`\ s. +// +// Parameters +// ---------- +// arg1, arg2 : dtype_like +// `dtype` or object coercible to one +// +// Returns +// ------- +// out : bool +// +// See Also +// -------- +// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. +// issubsctype, issubclass_ +// +// Examples +// -------- +// `issubdtype` can be used to check the type of arrays: +// +// >>> ints = np.array([1, 2, 3], dtype=np.int32) +// >>> np.issubdtype(ints.dtype, np.integer) +// True +// >>> np.issubdtype(ints.dtype, np.floating) +// False +// +// >>> floats = np.array([1, 2, 3], dtype=np.float32) +// >>> np.issubdtype(floats.dtype, np.integer) +// False +// >>> np.issubdtype(floats.dtype, np.floating) +// True +// +// Similar types of different sizes are not subdtypes of each other: +// +// >>> np.issubdtype(np.float64, np.float32) +// False +// >>> np.issubdtype(np.float32, np.float64) +// False +// +// but both are subtypes of `floating`: +// +// >>> np.issubdtype(np.float64, np.floating) +// True +// >>> np.issubdtype(np.float32, np.floating) +// True +// +// For convenience, dtype-like objects are allowed too: +// +// >>> np.issubdtype('S1', np.string_) +// True +// >>> np.issubdtype('i4', np.signedinteger) +// True +// +// +// +//go:linkname Issubdtype py.issubdtype +func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Set a Python function to be used when pretty printing arrays. +// +// Parameters +// ---------- +// f : function or None +// Function to be used to pretty print arrays. The function should expect +// a single array argument and return a string of the representation of +// the array. If None, the function is reset to the default NumPy function +// to print arrays. +// repr : bool, optional +// If True (default), the function for pretty printing (``__repr__``) +// is set, if False the function that returns the default string +// representation (``__str__``) is set. +// +// See Also +// -------- +// set_printoptions, get_printoptions +// +// Examples +// -------- +// >>> def pprint(arr): +// ... return 'HA! - What are you going to do now?' +// ... +// >>> np.set_string_function(pprint) +// >>> a = np.arange(10) +// >>> a +// HA! - What are you going to do now? +// >>> _ = a +// >>> # [0 1 2 3 4 5 6 7 8 9] +// +// We can reset the function to the default: +// +// >>> np.set_string_function(None) +// >>> a +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// +// `repr` affects either pretty printing or normal string representation. +// Note that ``__repr__`` is still affected by setting ``__str__`` +// because the width of each array element in the returned string becomes +// equal to the length of the result of ``__str__()``. +// +// >>> x = np.arange(4) +// >>> np.set_string_function(lambda x:'random', repr=False) +// >>> x.__str__() +// 'random' +// >>> x.__repr__() +// 'array([0, 1, 2, 3])' +// +// +// +//go:linkname SetStringFunction py.set_string_function +func SetStringFunction(f *py.Object, repr *py.Object) *py.Object +// +// Set printing options. +// +// These options determine the way floating point numbers, arrays and +// other NumPy objects are displayed. +// +// Parameters +// ---------- +// precision : int or None, optional +// Number of digits of precision for floating point output (default 8). +// May be None if `floatmode` is not `fixed`, to print as many digits as +// necessary to uniquely specify the value. +// threshold : int, optional +// Total number of array elements which trigger summarization +// rather than full repr (default 1000). +// To always use the full repr without summarization, pass `sys.maxsize`. +// edgeitems : int, optional +// Number of array items in summary at beginning and end of +// each dimension (default 3). +// linewidth : int, optional +// The number of characters per line for the purpose of inserting +// line breaks (default 75). +// suppress : bool, optional +// If True, always print floating point numbers using fixed point +// notation, in which case numbers equal to zero in the current precision +// will print as zero. If False, then scientific notation is used when +// absolute value of the smallest number is < 1e-4 or the ratio of the +// maximum absolute value to the minimum is > 1e3. The default is False. +// nanstr : str, optional +// String representation of floating point not-a-number (default nan). +// infstr : str, optional +// String representation of floating point infinity (default inf). +// sign : string, either '-', '+', or ' ', optional +// Controls printing of the sign of floating-point types. If '+', always +// print the sign of positive values. If ' ', always prints a space +// (whitespace character) in the sign position of positive values. If +// '-', omit the sign character of positive values. (default '-') +// formatter : dict of callables, optional +// If not None, the keys should indicate the type(s) that the respective +// formatting function applies to. Callables should return a string. +// Types that are not specified (by their corresponding keys) are handled +// by the default formatters. Individual types for which a formatter +// can be set are: +// +// - 'bool' +// - 'int' +// - 'timedelta' : a `numpy.timedelta64` +// - 'datetime' : a `numpy.datetime64` +// - 'float' +// - 'longfloat' : 128-bit floats +// - 'complexfloat' +// - 'longcomplexfloat' : composed of two 128-bit floats +// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` +// - 'object' : `np.object_` arrays +// +// Other keys that can be used to set a group of types at once are: +// +// - 'all' : sets all types +// - 'int_kind' : sets 'int' +// - 'float_kind' : sets 'float' and 'longfloat' +// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' +// - 'str_kind' : sets 'numpystr' +// floatmode : str, optional +// Controls the interpretation of the `precision` option for +// floating-point types. Can take the following values +// (default maxprec_equal): +// +// * 'fixed': Always print exactly `precision` fractional digits, +// even if this would print more or fewer digits than +// necessary to specify the value uniquely. +// * 'unique': Print the minimum number of fractional digits necessary +// to represent each value uniquely. Different elements may +// have a different number of digits. The value of the +// `precision` option is ignored. +// * 'maxprec': Print at most `precision` fractional digits, but if +// an element can be uniquely represented with fewer digits +// only print it with that many. +// * 'maxprec_equal': Print at most `precision` fractional digits, +// but if every element in the array can be uniquely +// represented with an equal number of fewer digits, use that +// many digits for all elements. +// legacy : string or `False`, optional +// If set to the string `'1.13'` enables 1.13 legacy printing mode. This +// approximates numpy 1.13 print output by including a space in the sign +// position of floats and different behavior for 0d arrays. This also +// enables 1.21 legacy printing mode (described below). +// +// If set to the string `'1.21'` enables 1.21 legacy printing mode. This +// approximates numpy 1.21 print output of complex structured dtypes +// by not inserting spaces after commas that separate fields and after +// colons. +// +// If set to `False`, disables legacy mode. +// +// Unrecognized strings will be ignored with a warning for forward +// compatibility. +// +// .. versionadded:: 1.14.0 +// .. versionchanged:: 1.22.0 +// +// See Also +// -------- +// get_printoptions, printoptions, set_string_function, array2string +// +// Notes +// ----- +// `formatter` is always reset with a call to `set_printoptions`. +// +// Use `printoptions` as a context manager to set the values temporarily. +// +// Examples +// -------- +// Floating point precision can be set: +// +// >>> np.set_printoptions(precision=4) +// >>> np.array([1.123456789]) +// [1.1235] +// +// Long arrays can be summarised: +// +// >>> np.set_printoptions(threshold=5) +// >>> np.arange(10) +// array([0, 1, 2, ..., 7, 8, 9]) +// +// Small results can be suppressed: +// +// >>> eps = np.finfo(float).eps +// >>> x = np.arange(4.) +// >>> x**2 - (x + eps)**2 +// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) +// >>> np.set_printoptions(suppress=True) +// >>> x**2 - (x + eps)**2 +// array([-0., -0., 0., 0.]) +// +// A custom formatter can be used to display array elements as desired: +// +// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) +// >>> x = np.arange(3) +// >>> x +// array([int: 0, int: -1, int: -2]) +// >>> np.set_printoptions() # formatter gets reset +// >>> x +// array([0, 1, 2]) +// +// To put back the default options, you can use: +// +// >>> np.set_printoptions(edgeitems=3, infstr='inf', +// ... linewidth=75, nanstr='nan', precision=8, +// ... suppress=False, threshold=1000, formatter=None) +// +// Also to temporarily override options, use `printoptions` as a context manager: +// +// >>> with np.printoptions(precision=2, suppress=True, threshold=5): +// ... np.linspace(0, 10, 10) +// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) +// +// +// +//go:linkname SetPrintoptions py.set_printoptions +func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object +// +// Return the current print options. +// +// Returns +// ------- +// print_opts : dict +// Dictionary of current print options with keys +// +// - precision : int +// - threshold : int +// - edgeitems : int +// - linewidth : int +// - suppress : bool +// - nanstr : str +// - infstr : str +// - formatter : dict of callables +// - sign : str +// +// For a full description of these options, see `set_printoptions`. +// +// See Also +// -------- +// set_printoptions, printoptions, set_string_function +// +// +// +//go:linkname GetPrintoptions py.get_printoptions +func GetPrintoptions() *py.Object +// Context manager for setting print options. +// +// Set print options for the scope of the `with` block, and restore the old +// options at the end. See `set_printoptions` for the full description of +// available options. +// +// Examples +// -------- +// +// >>> from numpy.testing import assert_equal +// >>> with np.printoptions(precision=2): +// ... np.array([2.0]) / 3 +// array([0.67]) +// +// The `as`-clause of the `with`-statement gives the current print options: +// +// >>> with np.printoptions(precision=2) as opts: +// ... assert_equal(opts, np.get_printoptions()) +// +// See Also +// -------- +// set_printoptions, get_printoptions +// +// +// +//go:linkname Printoptions py.printoptions +func Printoptions(__llgo_va_list ...interface{}) *py.Object +// +// Format a floating-point scalar as a decimal string in positional notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed, or if `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// fractional : boolean, optional +// If `True`, the cutoffs of `precision` and `min_digits` refer to the +// total number of digits after the decimal point, including leading +// zeros. +// If `False`, `precision` and `min_digits` refer to the total number of +// significant digits, before or after the decimal point, ignoring leading +// zeros. +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// pad_right : non-negative integer, optional +// Pad the right side of the string with whitespace until at least that +// many characters are to the right of the decimal point. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. Only has an effect if `unique=True` +// in which case additional digits past those necessary to uniquely +// identify the value may be printed, rounding the last additional digit. +// +// -- versionadded:: 1.21.0 +// +// Returns +// ------- +// rep : string +// The string representation of the floating point value +// +// See Also +// -------- +// format_float_scientific +// +// Examples +// -------- +// >>> np.format_float_positional(np.float32(np.pi)) +// '3.1415927' +// >>> np.format_float_positional(np.float16(np.pi)) +// '3.14' +// >>> np.format_float_positional(np.float16(0.3)) +// '0.3' +// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) +// '0.3000488281' +// +// +//go:linkname FormatFloatPositional py.format_float_positional +func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object +// +// Format a floating-point scalar as a decimal string in scientific notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed. If `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// exp_digits : non-negative integer, optional +// Pad the exponent with zeros until it contains at least this many digits. +// If omitted, the exponent will be at least 2 digits. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. This only has an effect for +// `unique=True`. In that case more digits than necessary to uniquely +// identify the value may be printed and rounded unbiased. +// +// -- versionadded:: 1.21.0 +// +// Returns +// ------- +// rep : string +// The string representation of the floating point value +// +// See Also +// -------- +// format_float_positional +// +// Examples +// -------- +// >>> np.format_float_scientific(np.float32(np.pi)) +// '3.1415927e+00' +// >>> s = np.float32(1.23e24) +// >>> np.format_float_scientific(s, unique=False, precision=15) +// '1.230000071797338e+24' +// >>> np.format_float_scientific(s, exp_digits=4) +// '1.23e+0024' +// +// +//go:linkname FormatFloatScientific py.format_float_scientific +func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object +// +// Return an ndarray of the provided type that satisfies requirements. +// +// This function is useful to be sure that an array with the correct flags +// is returned for passing to compiled code (perhaps through ctypes). +// +// Parameters +// ---------- +// a : array_like +// The object to be converted to a type-and-requirement-satisfying array. +// dtype : data-type +// The required data-type. If None preserve the current dtype. If your +// application requires the data to be in native byteorder, include +// a byteorder specification as a part of the dtype specification. +// requirements : str or sequence of str +// The requirements list can be any of the following +// +// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array +// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array +// * 'ALIGNED' ('A') - ensure a data-type aligned array +// * 'WRITEABLE' ('W') - ensure a writable array +// * 'OWNDATA' ('O') - ensure an array that owns its own data +// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array with specified requirements and type if given. +// +// See Also +// -------- +// asarray : Convert input to an ndarray. +// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// ndarray.flags : Information about the memory layout of the array. +// +// Notes +// ----- +// The returned array will be guaranteed to have the listed requirements +// by making a copy if needed. +// +// Examples +// -------- +// >>> x = np.arange(6).reshape(2,3) +// >>> x.flags +// C_CONTIGUOUS : True +// F_CONTIGUOUS : False +// OWNDATA : False +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False +// +// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) +// >>> y.flags +// C_CONTIGUOUS : False +// F_CONTIGUOUS : True +// OWNDATA : True +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False +// +// +// +//go:linkname Require py.require +func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object +// +// Set how floating-point errors are handled. +// +// Note that operations on integer scalar types (such as `int16`) are +// handled like floating point, and are affected by these settings. +// +// Parameters +// ---------- +// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Set treatment for all types of floating-point errors at once: +// +// - ignore: Take no action when the exception occurs. +// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). +// - raise: Raise a `FloatingPointError`. +// - call: Call a function specified using the `seterrcall` function. +// - print: Print a warning directly to ``stdout``. +// - log: Record error in a Log object specified by `seterrcall`. +// +// The default is not to change the current behavior. +// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for division by zero. +// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point overflow. +// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point underflow. +// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for invalid floating-point operation. +// +// Returns +// ------- +// old_settings : dict +// Dictionary containing the old settings. +// +// See also +// -------- +// seterrcall : Set a callback function for the 'call' mode. +// geterr, geterrcall, errstate +// +// Notes +// ----- +// The floating-point exceptions are defined in the IEEE 754 standard [1]_: +// +// - Division by zero: infinite result obtained from finite numbers. +// - Overflow: result too large to be expressed. +// - Underflow: result so close to zero that some precision +// was lost. +// - Invalid operation: result is not an expressible number, typically +// indicates that a NaN was produced. +// +// .. [1] https://en.wikipedia.org/wiki/IEEE_754 +// +// Examples +// -------- +// >>> old_settings = np.seterr(all='ignore') #seterr to known value +// >>> np.seterr(over='raise') +// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} +// >>> np.seterr(**old_settings) # reset to default +// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} +// +// >>> np.int16(32000) * np.int16(3) +// 30464 +// >>> old_settings = np.seterr(all='warn', over='raise') +// >>> np.int16(32000) * np.int16(3) +// Traceback (most recent call last): +// File "", line 1, in +// FloatingPointError: overflow encountered in scalar multiply +// +// >>> old_settings = np.seterr(all='print') +// >>> np.geterr() +// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} +// >>> np.int16(32000) * np.int16(3) +// 30464 +// +// +// +//go:linkname Seterr py.seterr +func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object +// +// Get the current way of handling floating-point errors. +// +// Returns +// ------- +// res : dict +// A dictionary with keys "divide", "over", "under", and "invalid", +// whose values are from the strings "ignore", "print", "log", "warn", +// "raise", and "call". The keys represent possible floating-point +// exceptions, and the values define how these exceptions are handled. +// +// See Also +// -------- +// geterrcall, seterr, seterrcall +// +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. +// +// Examples +// -------- +// >>> np.geterr() +// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) +// +// >>> oldsettings = np.seterr(all='warn', over='raise') +// >>> np.geterr() +// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) +// +// +// +//go:linkname Geterr py.geterr +func Geterr() *py.Object +// +// Set the size of the buffer used in ufuncs. +// +// Parameters +// ---------- +// size : int +// Size of buffer. +// +// +// +//go:linkname Setbufsize py.setbufsize +func Setbufsize(size *py.Object) *py.Object +// +// Return the size of the buffer used in ufuncs. +// +// Returns +// ------- +// getbufsize : int +// Size of ufunc buffer in bytes. +// +// +// +//go:linkname Getbufsize py.getbufsize +func Getbufsize() *py.Object +// +// Set the floating-point error callback function or log object. +// +// There are two ways to capture floating-point error messages. The first +// is to set the error-handler to 'call', using `seterr`. Then, set +// the function to call using this function. +// +// The second is to set the error-handler to 'log', using `seterr`. +// Floating-point errors then trigger a call to the 'write' method of +// the provided object. +// +// Parameters +// ---------- +// func : callable f(err, flag) or object with write method +// Function to call upon floating-point errors ('call'-mode) or +// object whose 'write' method is used to log such message ('log'-mode). +// +// The call function takes two arguments. The first is a string describing +// the type of error (such as "divide by zero", "overflow", "underflow", +// or "invalid value"), and the second is the status flag. The flag is a +// byte, whose four least-significant bits indicate the type of error, one +// of "divide", "over", "under", "invalid":: +// +// [0 0 0 0 divide over under invalid] +// +// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. +// +// If an object is provided, its write method should take one argument, +// a string. +// +// Returns +// ------- +// h : callable, log instance or None +// The old error handler. +// +// See Also +// -------- +// seterr, geterr, geterrcall +// +// Examples +// -------- +// Callback upon error: +// +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// ... +// +// >>> saved_handler = np.seterrcall(err_handler) +// >>> save_err = np.seterr(all='call') +// +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) +// +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} +// +// Log error message: +// +// >>> class Log: +// ... def write(self, msg): +// ... print("LOG: %s" % msg) +// ... +// +// >>> log = Log() +// >>> saved_handler = np.seterrcall(log) +// >>> save_err = np.seterr(all='log') +// +// >>> np.array([1, 2, 3]) / 0.0 +// LOG: Warning: divide by zero encountered in divide +// array([inf, inf, inf]) +// +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} +// +// +// +//go:linkname Seterrcall py.seterrcall +func Seterrcall(func_ *py.Object) *py.Object +// +// Return the current callback function used on floating-point errors. +// +// When the error handling for a floating-point error (one of "divide", +// "over", "under", or "invalid") is set to 'call' or 'log', the function +// that is called or the log instance that is written to is returned by +// `geterrcall`. This function or log instance has been set with +// `seterrcall`. +// +// Returns +// ------- +// errobj : callable, log instance or None +// The current error handler. If no handler was set through `seterrcall`, +// ``None`` is returned. +// +// See Also +// -------- +// seterrcall, seterr, geterr +// +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. +// +// Examples +// -------- +// >>> np.geterrcall() # we did not yet set a handler, returns None +// +// >>> oldsettings = np.seterr(all='call') +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// >>> oldhandler = np.seterrcall(err_handler) +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) +// +// >>> cur_handler = np.geterrcall() +// >>> cur_handler is err_handler +// True +// +// +// +//go:linkname Geterrcall py.geterrcall +func Geterrcall() *py.Object +// +// Return a description for the given data type code. +// +// Parameters +// ---------- +// char : str +// Data type code. +// +// Returns +// ------- +// out : str +// Description of the input data type code. +// +// See Also +// -------- +// dtype, typecodes +// +// Examples +// -------- +// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', +// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] +// >>> for typechar in typechars: +// ... print(typechar, ' : ', np.typename(typechar)) +// ... +// S1 : character +// ? : bool +// B : unsigned char +// D : complex double precision +// G : complex long double precision +// F : complex single precision +// I : unsigned integer +// H : unsigned short +// L : unsigned long integer +// O : object +// Q : unsigned long long integer +// S : string +// U : unicode +// V : void +// b : signed char +// d : double precision +// g : long precision +// f : single precision +// i : integer +// h : short +// l : long integer +// q : long long integer +// +// +// +//go:linkname Typename py.typename +func Typename(char *py.Object) *py.Object +// +// Return the character for the minimum-size type to which given types can +// be safely cast. +// +// The returned type character must represent the smallest size dtype such +// that an array of the returned type can handle the data from an array of +// all types in `typechars` (or if `typechars` is an array, then its +// dtype.char). +// +// Parameters +// ---------- +// typechars : list of str or array_like +// If a list of strings, each string should represent a dtype. +// If array_like, the character representation of the array dtype is used. +// typeset : str or list of str, optional +// The set of characters that the returned character is chosen from. +// The default set is 'GDFgdf'. +// default : str, optional +// The default character, this is returned if none of the characters in +// `typechars` matches a character in `typeset`. +// +// Returns +// ------- +// typechar : str +// The character representing the minimum-size type that was found. +// +// See Also +// -------- +// dtype, sctype2char, maximum_sctype +// +// Examples +// -------- +// >>> np.mintypecode(['d', 'f', 'S']) +// 'd' +// >>> x = np.array([1.1, 2-3.j]) +// >>> np.mintypecode(x) +// 'D' +// +// >>> np.mintypecode('abceh', default='G') +// 'G' +// +// +// +//go:linkname Mintypecode py.mintypecode +func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *py.Object) *py.Object +// +// Return the indices to access the main diagonal of an array. +// +// This returns a tuple of indices that can be used to access the main +// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape +// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for +// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` +// for ``i = [0..n-1]``. +// +// Parameters +// ---------- +// n : int +// The size, along each dimension, of the arrays for which the returned +// indices can be used. +// +// ndim : int, optional +// The number of dimensions. +// +// See Also +// -------- +// diag_indices_from +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Create a set of indices to access the diagonal of a (4, 4) array: +// +// >>> di = np.diag_indices(4) +// >>> di +// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// >>> a[di] = 100 +// >>> a +// array([[100, 1, 2, 3], +// [ 4, 100, 6, 7], +// [ 8, 9, 100, 11], +// [ 12, 13, 14, 100]]) +// +// Now, we create indices to manipulate a 3-D array: +// +// >>> d3 = np.diag_indices(2, 3) +// >>> d3 +// (array([0, 1]), array([0, 1]), array([0, 1])) +// +// And use it to set the diagonal of an array of zeros to 1: +// +// >>> a = np.zeros((2, 2, 2), dtype=int) +// >>> a[d3] = 1 +// >>> a +// array([[[1, 0], +// [0, 0]], +// [[0, 0], +// [0, 1]]]) +// +// +// +//go:linkname DiagIndices py.diag_indices +func DiagIndices(n *py.Object, ndim *py.Object) *py.Object +// +// Check whether or not an object can be iterated over. +// +// Parameters +// ---------- +// y : object +// Input object. +// +// Returns +// ------- +// b : bool +// Return ``True`` if the object has an iterator method or is a +// sequence and ``False`` otherwise. +// +// +// Examples +// -------- +// >>> np.iterable([1, 2, 3]) +// True +// >>> np.iterable(2) +// False +// +// Notes +// ----- +// In most cases, the results of ``np.iterable(obj)`` are consistent with +// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is +// the treatment of 0-dimensional arrays:: +// +// >>> from collections.abc import Iterable +// >>> a = np.array(1.0) # 0-dimensional numpy array +// >>> isinstance(a, Iterable) +// True +// >>> np.iterable(a) +// False +// +// +// +//go:linkname Iterable py.iterable +func Iterable(y *py.Object) *py.Object +// +// Display a message on a device. +// +// Parameters +// ---------- +// mesg : str +// Message to display. +// device : object +// Device to write message. If None, defaults to ``sys.stdout`` which is +// very similar to ``print``. `device` needs to have ``write()`` and +// ``flush()`` methods. +// linefeed : bool, optional +// Option whether to print a line feed or not. Defaults to True. +// +// Raises +// ------ +// AttributeError +// If `device` does not have a ``write()`` or ``flush()`` method. +// +// Examples +// -------- +// Besides ``sys.stdout``, a file-like object can also be used as it has +// both required methods: +// +// >>> from io import StringIO +// >>> buf = StringIO() +// >>> np.disp(u'"Display" in a file', device=buf) +// >>> buf.getvalue() +// '"Display" in a file\n' +// +// +// +//go:linkname Disp py.disp +func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object +// Convert the input to an array, checking for NaNs or Infs. +// +// Parameters +// ---------- +// a : array_like +// Input data, in any form that can be converted to an array. This +// includes lists, lists of tuples, tuples, tuples of tuples, tuples +// of lists and ndarrays. Success requires no NaNs or Infs. +// dtype : data-type, optional +// By default, the data-type is inferred from the input data. +// order : {'C', 'F', 'A', 'K'}, optional +// Memory layout. 'A' and 'K' depend on the order of input array a. +// 'C' row-major (C-style), +// 'F' column-major (Fortran-style) memory representation. +// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise +// 'K' (keep) preserve input order +// Defaults to 'C'. +// +// Returns +// ------- +// out : ndarray +// Array interpretation of `a`. No copy is performed if the input +// is already an ndarray. If `a` is a subclass of ndarray, a base +// class ndarray is returned. +// +// Raises +// ------ +// ValueError +// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). +// +// See Also +// -------- +// asarray : Create and array. +// asanyarray : Similar function which passes through subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfarray : Convert input to a floating point ndarray. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// fromiter : Create an array from an iterator. +// fromfunction : Construct an array by executing a function on grid +// positions. +// +// Examples +// -------- +// Convert a list into an array. If all elements are finite +// ``asarray_chkfinite`` is identical to ``asarray``. +// +// >>> a = [1, 2] +// >>> np.asarray_chkfinite(a, dtype=float) +// array([1., 2.]) +// +// Raises ValueError if array_like contains Nans or Infs. +// +// >>> a = [1, 2, np.inf] +// >>> try: +// ... np.asarray_chkfinite(a) +// ... except ValueError: +// ... print('ValueError') +// ... +// ValueError +// +// +// +//go:linkname AsarrayChkfinite py.asarray_chkfinite +func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// Return the Hamming window. +// +// The Hamming window is a taper formed by using a weighted cosine. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hanning, kaiser +// +// Notes +// ----- +// The Hamming window is defined as +// +// .. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 +// +// The Hamming was named for R. W. Hamming, an associate of J. W. Tukey +// and is described in Blackman and Tukey. It was recommended for +// smoothing the truncated autocovariance function in the time domain. +// Most references to the Hamming window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 109-110. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// +// Examples +// -------- +// >>> np.hamming(12) +// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary +// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, +// 0.15302337, 0.08 ]) +// +// Plot the window and the frequency response: +// +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hamming(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hamming window") +// Text(0.5, 1.0, 'Hamming window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Hamming window") +// Text(0.5, 1.0, 'Frequency response of Hamming window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() +// +// +// +//go:linkname Hamming py.hamming +func Hamming(M *py.Object) *py.Object +// +// Return the Hanning window. +// +// The Hanning window is a taper formed by using a weighted cosine. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : ndarray, shape(M,) +// The window, with the maximum value normalized to one (the value +// one appears only if `M` is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, kaiser +// +// Notes +// ----- +// The Hanning window is defined as +// +// .. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 +// +// The Hanning was named for Julius von Hann, an Austrian meteorologist. +// It is also known as the Cosine Bell. Some authors prefer that it be +// called a Hann window, to help avoid confusion with the very similar +// Hamming window. +// +// Most references to the Hanning window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 106-108. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// +// Examples +// -------- +// >>> np.hanning(12) +// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, +// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, +// 0.07937323, 0. ]) +// +// Plot the window and its frequency response: +// +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hanning(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hann window") +// Text(0.5, 1.0, 'Hann window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of the Hann window") +// Text(0.5, 1.0, 'Frequency response of the Hann window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() +// +// +// +//go:linkname Hanning py.hanning +func Hanning(M *py.Object) *py.Object +// +// Return the Bartlett window. +// +// The Bartlett window is very similar to a triangular window, except +// that the end points are at zero. It is often used in signal +// processing for tapering a signal, without generating too much +// ripple in the frequency domain. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// +// Returns +// ------- +// out : array +// The triangular window, with the maximum value normalized to one +// (the value one appears only if the number of samples is odd), with +// the first and last samples equal to zero. +// +// See Also +// -------- +// blackman, hamming, hanning, kaiser +// +// Notes +// ----- +// The Bartlett window is defined as +// +// .. math:: w(n) = \frac{2}{M-1} \left( +// \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| +// \right) +// +// Most references to the Bartlett window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. Note that convolution with this window produces linear +// interpolation. It is also known as an apodization (which means "removing +// the foot", i.e. smoothing discontinuities at the beginning and end of the +// sampled signal) or tapering function. The Fourier transform of the +// Bartlett window is the product of two sinc functions. Note the excellent +// discussion in Kanasewich [2]_. +// +// References +// ---------- +// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", +// Biometrika 37, 1-16, 1950. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 109-110. +// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal +// Processing", Prentice-Hall, 1999, pp. 468-471. +// .. [4] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 429. +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.bartlett(12) +// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary +// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, +// 0.18181818, 0. ]) +// +// Plot the window and its frequency response (requires SciPy and matplotlib): +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.bartlett(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Bartlett window") +// Text(0.5, 1.0, 'Bartlett window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Bartlett window") +// Text(0.5, 1.0, 'Frequency response of Bartlett window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() +// +// +// +//go:linkname Bartlett py.bartlett +func Bartlett(M *py.Object) *py.Object +// +// Return the Blackman window. +// +// The Blackman window is a taper formed by using the first three +// terms of a summation of cosines. It was designed to have close to the +// minimal leakage possible. It is close to optimal, only slightly worse +// than a Kaiser window. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an empty +// array is returned. +// +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value one +// appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, hamming, hanning, kaiser +// +// Notes +// ----- +// The Blackman window is defined as +// +// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) +// +// Most references to the Blackman window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. It is known as a +// "near optimal" tapering function, almost as good (by some measures) +// as the kaiser window. +// +// References +// ---------- +// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, +// Dover Publications, New York. +// +// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. +// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.blackman(12) +// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary +// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, +// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, +// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) +// +// Plot the window and the frequency response: +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.blackman(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Blackman window") +// Text(0.5, 1.0, 'Blackman window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Blackman window") +// Text(0.5, 1.0, 'Frequency response of Blackman window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() +// +// +// +//go:linkname Blackman py.blackman +func Blackman(M *py.Object) *py.Object +// +// Return the Kaiser window. +// +// The Kaiser window is a taper formed by using a Bessel function. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// beta : float +// Shape parameter for window. +// +// Returns +// ------- +// out : array +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, hanning +// +// Notes +// ----- +// The Kaiser window is defined as +// +// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} +// \right)/I_0(\beta) +// +// with +// +// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, +// +// where :math:`I_0` is the modified zeroth-order Bessel function. +// +// The Kaiser was named for Jim Kaiser, who discovered a simple +// approximation to the DPSS window based on Bessel functions. The Kaiser +// window is a very good approximation to the Digital Prolate Spheroidal +// Sequence, or Slepian window, which is the transform which maximizes the +// energy in the main lobe of the window relative to total energy. +// +// The Kaiser can approximate many other windows by varying the beta +// parameter. +// +// ==== ======================= +// beta Window shape +// ==== ======================= +// 0 Rectangular +// 5 Similar to a Hamming +// 6 Similar to a Hanning +// 8.6 Similar to a Blackman +// ==== ======================= +// +// A beta value of 14 is probably a good starting point. Note that as beta +// gets large, the window narrows, and so the number of samples needs to be +// large enough to sample the increasingly narrow spike, otherwise NaNs will +// get returned. +// +// Most references to the Kaiser window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. It is also known as an apodization (which means +// "removing the foot", i.e. smoothing discontinuities at the beginning +// and end of the sampled signal) or tapering function. +// +// References +// ---------- +// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by +// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. +// John Wiley and Sons, New York, (1966). +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 177-178. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.kaiser(12, 14) +// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary +// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, +// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, +// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) +// +// +// Plot the window and the frequency response: +// +// >>> from numpy.fft import fft, fftshift +// >>> window = np.kaiser(51, 14) +// >>> plt.plot(window) +// [] +// >>> plt.title("Kaiser window") +// Text(0.5, 1.0, 'Kaiser window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() +// +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Kaiser window") +// Text(0.5, 1.0, 'Frequency response of Kaiser window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// (-0.5, 0.5, -100.0, ...) # may vary +// >>> plt.show() +// +// +// +//go:linkname Kaiser py.kaiser +func Kaiser(M *py.Object, beta *py.Object) *py.Object +// +// Add documentation to an existing object, typically one defined in C +// +// The purpose is to allow easier editing of the docstrings without requiring +// a re-compile. This exists primarily for internal use within numpy itself. +// +// Parameters +// ---------- +// place : str +// The absolute name of the module to import from +// obj : str +// The name of the object to add documentation to, typically a class or +// function name +// doc : {str, Tuple[str, str], List[Tuple[str, str]]} +// If a string, the documentation to apply to `obj` +// +// If a tuple, then the first element is interpreted as an attribute of +// `obj` and the second as the docstring to apply - ``(method, docstring)`` +// +// If a list, then each element of the list should be a tuple of length +// two - ``[(method1, docstring1), (method2, docstring2), ...]`` +// warn_on_python : bool +// If True, the default, emit `UserWarning` if this is used to attach +// documentation to a pure-python object. +// +// Notes +// ----- +// This routine never raises an error if the docstring can't be written, but +// will raise an error if the object being documented does not exist. +// +// This routine cannot modify read-only docstrings, as appear +// in new-style classes or built-in functions. Because this +// routine never raises an error the caller must check manually +// that the docstrings were changed. +// +// Since this function grabs the ``char *`` from a c-level str object and puts +// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of +// C-API best-practices, by: +// +// - modifying a `PyTypeObject` after calling `PyType_Ready` +// - calling `Py_INCREF` on the str and losing the reference, so the str +// will never be released +// +// If possible it should be avoided. +// +// +//go:linkname AddNewdoc py.add_newdoc +func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object +// Find the wrapper for the array with the highest priority. +// +// In case of ties, leftmost wins. If no wrapper is found, return None +// +// +//go:linkname GetArrayWrap py.get_array_wrap +func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object +// +// Broadcast the input shapes into a single shape. +// +// :ref:`Learn more about broadcasting here `. +// +// .. versionadded:: 1.20.0 +// +// Parameters +// ---------- +// `*args` : tuples of ints, or ints +// The shapes to be broadcast against each other. +// +// Returns +// ------- +// tuple +// Broadcasted shape. +// +// Raises +// ------ +// ValueError +// If the shapes are not compatible and cannot be broadcast according +// to NumPy's broadcasting rules. +// +// See Also +// -------- +// broadcast +// broadcast_arrays +// broadcast_to +// +// Examples +// -------- +// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) +// (3, 2) +// +// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) +// (5, 6, 7) +// +// +//go:linkname BroadcastShapes py.broadcast_shapes +func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object +// +// Return a 2-D array with ones on the diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// Number of rows in the output. +// M : int, optional +// Number of columns in the output. If None, defaults to `N`. +// k : int, optional +// Index of the diagonal: 0 (the default) refers to the main diagonal, +// a positive value refers to an upper diagonal, and a negative value +// to a lower diagonal. +// dtype : data-type, optional +// Data-type of the returned array. +// order : {'C', 'F'}, optional +// Whether the output should be stored in row-major (C-style) or +// column-major (Fortran-style) order in memory. +// +// .. versionadded:: 1.14.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// I : ndarray of shape (N,M) +// An array where all elements are equal to zero, except for the `k`-th +// diagonal, whose values are equal to one. +// +// See Also +// -------- +// identity : (almost) equivalent function +// diag : diagonal 2-D array from a 1-D array specified by the user. +// +// Examples +// -------- +// >>> np.eye(2, dtype=int) +// array([[1, 0], +// [0, 1]]) +// >>> np.eye(3, k=1) +// array([[0., 1., 0.], +// [0., 0., 1.], +// [0., 0., 0.]]) +// +// +// +//go:linkname Eye py.eye +func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object +// +// An array with ones at and below the given diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// Number of rows in the array. +// M : int, optional +// Number of columns in the array. +// By default, `M` is taken equal to `N`. +// k : int, optional +// The sub-diagonal at and below which the array is filled. +// `k` = 0 is the main diagonal, while `k` < 0 is below it, +// and `k` > 0 is above. The default is 0. +// dtype : dtype, optional +// Data type of the returned array. The default is float. +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// tri : ndarray of shape (N, M) +// Array with its lower triangle filled with ones and zero elsewhere; +// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. +// +// Examples +// -------- +// >>> np.tri(3, 5, 2, dtype=int) +// array([[1, 1, 1, 0, 0], +// [1, 1, 1, 1, 0], +// [1, 1, 1, 1, 1]]) +// +// >>> np.tri(3, 5, -1) +// array([[0., 0., 0., 0., 0.], +// [1., 0., 0., 0., 0.], +// [1., 1., 0., 0., 0.]]) +// +// +// +//go:linkname Tri py.tri +func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object +// +// Return the indices to access (n, n) arrays, given a masking function. +// +// Assume `mask_func` is a function that, for a square array a of size +// ``(n, n)`` with a possible offset argument `k`, when called as +// ``mask_func(a, k)`` returns a new array with zeros in certain locations +// (functions like `triu` or `tril` do precisely this). Then this function +// returns the indices where the non-zero values would be located. +// +// Parameters +// ---------- +// n : int +// The returned indices will be valid to access arrays of shape (n, n). +// mask_func : callable +// A function whose call signature is similar to that of `triu`, `tril`. +// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. +// `k` is an optional argument to the function. +// k : scalar +// An optional argument which is passed through to `mask_func`. Functions +// like `triu`, `tril` take a second argument that is interpreted as an +// offset. +// +// Returns +// ------- +// indices : tuple of arrays. +// The `n` arrays of indices corresponding to the locations where +// ``mask_func(np.ones((n, n)), k)`` is True. +// +// See Also +// -------- +// triu, tril, triu_indices, tril_indices +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// These are the indices that would allow you to access the upper triangular +// part of any 3x3 array: +// +// >>> iu = np.mask_indices(3, np.triu) +// +// For example, if `a` is a 3x3 array: +// +// >>> a = np.arange(9).reshape(3, 3) +// >>> a +// array([[0, 1, 2], +// [3, 4, 5], +// [6, 7, 8]]) +// >>> a[iu] +// array([0, 1, 2, 4, 5, 8]) +// +// An offset can be passed also to the masking function. This gets us the +// indices starting on the first diagonal right of the main one: +// +// >>> iu1 = np.mask_indices(3, np.triu, 1) +// +// with which we now extract only three elements: +// +// >>> a[iu1] +// array([1, 2, 5]) +// +// +// +//go:linkname MaskIndices py.mask_indices +func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object +// +// Return the indices for the lower-triangle of an (n, m) array. +// +// Parameters +// ---------- +// n : int +// The row dimension of the arrays for which the returned +// indices will be valid. +// k : int, optional +// Diagonal offset (see `tril` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// +// +// Returns +// ------- +// inds : tuple of arrays +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. +// +// See also +// -------- +// triu_indices : similar function, for upper-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// tril, triu +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Compute two different sets of indices to access 4x4 arrays, one for the +// lower triangular part starting at the main diagonal, and one starting two +// diagonals further right: +// +// >>> il1 = np.tril_indices(4) +// >>> il2 = np.tril_indices(4, 2) +// +// Here is how they can be used with a sample array: +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Both for indexing: +// +// >>> a[il1] +// array([ 0, 4, 5, ..., 13, 14, 15]) +// +// And for assigning values: +// +// >>> a[il1] = -1 +// >>> a +// array([[-1, 1, 2, 3], +// [-1, -1, 6, 7], +// [-1, -1, -1, 11], +// [-1, -1, -1, -1]]) +// +// These cover almost the whole array (two diagonals right of the main one): +// +// >>> a[il2] = -10 +// >>> a +// array([[-10, -10, -10, 3], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10]]) +// +// +// +//go:linkname TrilIndices py.tril_indices +func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Return the indices for the upper-triangle of an (n, m) array. +// +// Parameters +// ---------- +// n : int +// The size of the arrays for which the returned indices will +// be valid. +// k : int, optional +// Diagonal offset (see `triu` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// +// +// Returns +// ------- +// inds : tuple, shape(2) of ndarrays, shape(`n`) +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. Can be used +// to slice a ndarray of shape(`n`, `n`). +// +// See also +// -------- +// tril_indices : similar function, for lower-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// triu, tril +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// Compute two different sets of indices to access 4x4 arrays, one for the +// upper triangular part starting at the main diagonal, and one starting two +// diagonals further right: +// +// >>> iu1 = np.triu_indices(4) +// >>> iu2 = np.triu_indices(4, 2) +// +// Here is how they can be used with a sample array: +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Both for indexing: +// +// >>> a[iu1] +// array([ 0, 1, 2, ..., 10, 11, 15]) +// +// And for assigning values: +// +// >>> a[iu1] = -1 +// >>> a +// array([[-1, -1, -1, -1], +// [ 4, -1, -1, -1], +// [ 8, 9, -1, -1], +// [12, 13, 14, -1]]) +// +// These cover only a small part of the whole array (two diagonals right +// of the main one): +// +// >>> a[iu2] = -10 +// >>> a +// array([[ -1, -1, -10, -10], +// [ 4, -1, -1, -10], +// [ 8, 9, -1, -1], +// [ 12, 13, 14, -1]]) +// +// +// +//go:linkname TriuIndices py.triu_indices +func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Determine if a class is a subclass of a second class. +// +// `issubclass_` is equivalent to the Python built-in ``issubclass``, +// except that it returns False instead of raising a TypeError if one +// of the arguments is not a class. +// +// Parameters +// ---------- +// arg1 : class +// Input class. True is returned if `arg1` is a subclass of `arg2`. +// arg2 : class or tuple of classes. +// Input class. If a tuple of classes, True is returned if `arg1` is a +// subclass of any of the tuple elements. +// +// Returns +// ------- +// out : bool +// Whether `arg1` is a subclass of `arg2` or not. +// +// See Also +// -------- +// issubsctype, issubdtype, issctype +// +// Examples +// -------- +// >>> np.issubclass_(np.int32, int) +// False +// >>> np.issubclass_(np.int32, float) +// False +// >>> np.issubclass_(np.float64, float) +// True +// +// +// +//go:linkname Issubclass py.issubclass_ +func Issubclass(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Determine if the first argument is a subclass of the second argument. +// +// Parameters +// ---------- +// arg1, arg2 : dtype or dtype specifier +// Data-types. +// +// Returns +// ------- +// out : bool +// The result. +// +// See Also +// -------- +// issctype, issubdtype, obj2sctype +// +// Examples +// -------- +// >>> np.issubsctype('S8', str) +// False +// >>> np.issubsctype(np.array([1]), int) +// True +// >>> np.issubsctype(np.array([1]), float) +// False +// +// +// +//go:linkname Issubsctype py.issubsctype +func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object +// +// Issues a DeprecationWarning, adds warning to `old_name`'s +// docstring, rebinds ``old_name.__name__`` and returns the new +// function object. +// +// This function may also be used as a decorator. +// +// Parameters +// ---------- +// func : function +// The function to be deprecated. +// old_name : str, optional +// The name of the function to be deprecated. Default is None, in +// which case the name of `func` is used. +// new_name : str, optional +// The new name for the function. Default is None, in which case the +// deprecation message is that `old_name` is deprecated. If given, the +// deprecation message is that `old_name` is deprecated and `new_name` +// should be used instead. +// message : str, optional +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. +// +// Returns +// ------- +// old_func : function +// The deprecated function. +// +// Examples +// -------- +// Note that ``olduint`` returns a value after printing Deprecation +// Warning: +// +// >>> olduint = np.deprecate(np.uint) +// DeprecationWarning: `uint64` is deprecated! # may vary +// >>> olduint(6) +// 6 +// +// +// +//go:linkname Deprecate py.deprecate +func Deprecate(__llgo_va_list ...interface{}) *py.Object +// +// Deprecates a function and includes the deprecation in its docstring. +// +// This function is used as a decorator. It returns an object that can be +// used to issue a DeprecationWarning, by passing the to-be decorated +// function as argument, this adds warning to the to-be decorated function's +// docstring and returns the new function object. +// +// See Also +// -------- +// deprecate : Decorate a function such that it issues a `DeprecationWarning` +// +// Parameters +// ---------- +// msg : str +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. +// +// Returns +// ------- +// obj : object +// +// +// +//go:linkname DeprecateWithDoc py.deprecate_with_doc +func DeprecateWithDoc(msg *py.Object) *py.Object +// +// Return the directory that contains the NumPy \*.h header files. +// +// Extension modules that need to compile against NumPy should use this +// function to locate the appropriate include directory. +// +// Notes +// ----- +// When using ``distutils``, for example in ``setup.py``:: +// +// import numpy as np +// ... +// Extension('extension_name', ... +// include_dirs=[np.get_include()]) +// ... +// +// +// +//go:linkname GetInclude py.get_include +func GetInclude() *py.Object +// +// Get help information for an array, function, class, or module. +// +// Parameters +// ---------- +// object : object or str, optional +// Input object or name to get information about. If `object` is +// an `ndarray` instance, information about the array is printed. +// If `object` is a numpy object, its docstring is given. If it is +// a string, available modules are searched for matching objects. +// If None, information about `info` itself is returned. +// maxwidth : int, optional +// Printing width. +// output : file like object, optional +// File like object that the output is written to, default is +// ``None``, in which case ``sys.stdout`` will be used. +// The object has to be opened in 'w' or 'a' mode. +// toplevel : str, optional +// Start search at this level. +// +// See Also +// -------- +// source, lookfor +// +// Notes +// ----- +// When used interactively with an object, ``np.info(obj)`` is equivalent +// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython +// prompt. +// +// Examples +// -------- +// >>> np.info(np.polyval) # doctest: +SKIP +// polyval(p, x) +// Evaluate the polynomial p at x. +// ... +// +// When using a string for `object` it is possible to get multiple results. +// +// >>> np.info('fft') # doctest: +SKIP +// *** Found in numpy *** +// Core FFT routines +// ... +// *** Found in numpy.fft *** +// fft(a, n=None, axis=-1) +// ... +// *** Repeat reference found in numpy.fft.fftpack *** +// *** Total of 3 references found. *** +// +// When the argument is an array, information about the array is printed. +// +// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) +// >>> np.info(a) +// class: ndarray +// shape: (2, 3) +// strides: (24, 8) +// itemsize: 8 +// aligned: True +// contiguous: True +// fortran: False +// data pointer: 0x562b6e0d2860 # may vary +// byteorder: little +// byteswap: False +// type: complex64 +// +// +// +//go:linkname Info py.info +func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object +// +// Print or write to a file the source code for a NumPy object. +// +// The source code is only returned for objects written in Python. Many +// functions and classes are defined in C and will therefore not return +// useful information. +// +// Parameters +// ---------- +// object : numpy object +// Input object. This can be any object (function, class, module, +// ...). +// output : file object, optional +// If `output` not supplied then source code is printed to screen +// (sys.stdout). File object must be created with either write 'w' or +// append 'a' modes. +// +// See Also +// -------- +// lookfor, info +// +// Examples +// -------- +// >>> np.source(np.interp) #doctest: +SKIP +// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py +// def interp(x, xp, fp, left=None, right=None): +// """.... (full docstring printed)""" +// if isinstance(x, (float, int, number)): +// return compiled_interp([x], xp, fp, left, right).item() +// else: +// return compiled_interp(x, xp, fp, left, right) +// +// The source code is only returned for objects written in Python. +// +// >>> np.source(np.array) #doctest: +SKIP +// Not available for this object. +// +// +// +//go:linkname Source py.source +func Source(object *py.Object, output *py.Object) *py.Object +// +// Print the NumPy arrays in the given dictionary. +// +// If there is no dictionary passed in or `vardict` is None then returns +// NumPy arrays in the globals() dictionary (all NumPy arrays in the +// namespace). +// +// Parameters +// ---------- +// vardict : dict, optional +// A dictionary possibly containing ndarrays. Default is globals(). +// +// Returns +// ------- +// out : None +// Returns 'None'. +// +// Notes +// ----- +// Prints out the name, shape, bytes and type of all of the ndarrays +// present in `vardict`. +// +// Examples +// -------- +// >>> a = np.arange(10) +// >>> b = np.ones(20) +// >>> np.who() +// Name Shape Bytes Type +// =========================================================== +// a 10 80 int64 +// b 20 160 float64 +// Upper bound on total bytes = 240 +// +// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', +// ... 'idx':5} +// >>> np.who(d) +// Name Shape Bytes Type +// =========================================================== +// x 2 16 float64 +// y 3 24 float64 +// Upper bound on total bytes = 40 +// +// +// +//go:linkname Who py.who +func Who(vardict *py.Object) *py.Object +// +// Do a keyword search on docstrings. +// +// A list of objects that matched the search is displayed, +// sorted by relevance. All given keywords need to be found in the +// docstring for it to be returned as a result, but the order does +// not matter. +// +// Parameters +// ---------- +// what : str +// String containing words to look for. +// module : str or list, optional +// Name of module(s) whose docstrings to go through. +// import_modules : bool, optional +// Whether to import sub-modules in packages. Default is True. +// regenerate : bool, optional +// Whether to re-generate the docstring cache. Default is False. +// output : file-like, optional +// File-like object to write the output to. If omitted, use a pager. +// +// See Also +// -------- +// source, info +// +// Notes +// ----- +// Relevance is determined only roughly, by checking if the keywords occur +// in the function name, at the start of a docstring, etc. +// +// Examples +// -------- +// >>> np.lookfor('binary representation') # doctest: +SKIP +// Search results for 'binary representation' +// ------------------------------------------ +// numpy.binary_repr +// Return the binary representation of the input number as a string. +// numpy.core.setup_common.long_double_representation +// Given a binary dump as given by GNU od -b, look for long double +// numpy.base_repr +// Return a string representation of a number in the given base system. +// ... +// +// +// +//go:linkname Lookfor py.lookfor +func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object +// +// Returns pointers to the end-points of an array. +// +// Parameters +// ---------- +// a : ndarray +// Input array. It must conform to the Python-side of the array +// interface. +// +// Returns +// ------- +// (low, high) : tuple of 2 integers +// The first integer is the first byte of the array, the second +// integer is just past the last byte of the array. If `a` is not +// contiguous it will not use every byte between the (`low`, `high`) +// values. +// +// Examples +// -------- +// >>> I = np.eye(2, dtype='f'); I.dtype +// dtype('float32') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// >>> I = np.eye(2); I.dtype +// dtype('float64') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// +// +// +//go:linkname ByteBounds py.byte_bounds +func ByteBounds(a *py.Object) *py.Object +// +// Protected string evaluation. +// +// Evaluate a string containing a Python literal expression without +// allowing the execution of arbitrary non-literal code. +// +// .. warning:: +// +// This function is identical to :py:meth:`ast.literal_eval` and +// has the same security implications. It may not always be safe +// to evaluate large input strings. +// +// Parameters +// ---------- +// source : str +// The string to evaluate. +// +// Returns +// ------- +// obj : object +// The result of evaluating `source`. +// +// Raises +// ------ +// SyntaxError +// If the code has invalid Python syntax, or if it contains +// non-literal code. +// +// Examples +// -------- +// >>> np.safe_eval('1') +// 1 +// >>> np.safe_eval('[1, 2, 3]') +// [1, 2, 3] +// >>> np.safe_eval('{"foo": ("bar", 10.0)}') +// {'foo': ('bar', 10.0)} +// +// >>> np.safe_eval('import os') +// Traceback (most recent call last): +// ... +// SyntaxError: invalid syntax +// +// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') +// Traceback (most recent call last): +// ... +// ValueError: malformed node or string: <_ast.Call object at 0x...> +// +// +// +//go:linkname SafeEval py.safe_eval +func SafeEval(source *py.Object) *py.Object +// +// Print information about various resources in the system +// including available intrinsic support and BLAS/LAPACK library +// in use +// +// .. versionadded:: 1.24.0 +// +// See Also +// -------- +// show_config : Show libraries in the system on which NumPy was built. +// +// Notes +// ----- +// 1. Information is derived with the help of `threadpoolctl `_ +// library if available. +// 2. SIMD related information is derived from ``__cpu_features__``, +// ``__cpu_baseline__`` and ``__cpu_dispatch__`` +// +// +// +//go:linkname ShowRuntime py.show_runtime +func ShowRuntime() *py.Object +// +// Load data from a text file. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : data-type, optional +// Data-type of the resulting array; default: float. If this is a +// structured data-type, the resulting array will be 1-dimensional, and +// each row will be interpreted as an element of the array. In this +// case, the number of columns used must match the number of fields in +// the data-type. +// comments : str or sequence of str or None, optional +// The characters or list of characters used to indicate the start of a +// comment. None implies no comments. For backwards compatibility, byte +// strings will be decoded as 'latin1'. The default is '#'. +// delimiter : str, optional +// The character used to separate the values. For backwards compatibility, +// byte strings will be decoded as 'latin1'. The default is whitespace. +// +// .. versionchanged:: 1.23.0 +// Only single character delimiters are supported. Newline characters +// cannot be used as the delimiter. +// +// converters : dict or callable, optional +// Converter functions to customize value parsing. If `converters` is +// callable, the function is applied to all columns, else it must be a +// dict that maps column number to a parser function. +// See examples for further details. +// Default: None. +// +// .. versionchanged:: 1.23.0 +// The ability to pass a single callable to be applied to all columns +// was added. +// +// skiprows : int, optional +// Skip the first `skiprows` lines, including comments; default: 0. +// usecols : int or sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. +// The default, None, results in all columns being read. +// +// .. versionchanged:: 1.11.0 +// When a single column has to be read it is possible to use +// an integer instead of a tuple. E.g ``usecols = 3`` reads the +// fourth column the same way as ``usecols = (3,)`` would. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = loadtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// ndmin : int, optional +// The returned array will have at least `ndmin` dimensions. +// Otherwise mono-dimensional axes will be squeezed. +// Legal values: 0 (default), 1 or 2. +// +// .. versionadded:: 1.6.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply to input streams. +// The special value 'bytes' enables backward compatibility workarounds +// that ensures you receive byte arrays as results if possible and passes +// 'latin1' encoded strings to converters. Override this value to receive +// unicode arrays and pass strings as input to converters. If set to None +// the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// max_rows : int, optional +// Read `max_rows` rows of content after `skiprows` lines. The default is +// to read all the rows. Note that empty rows containing no data such as +// empty lines and comment lines are not counted towards `max_rows`, +// while such lines are counted in `skiprows`. +// +// .. versionadded:: 1.16.0 +// +// .. versionchanged:: 1.23.0 +// Lines containing no data, including comment lines (e.g., lines +// starting with '#' or as specified via `comments`) are not counted +// towards `max_rows`. +// quotechar : unicode character or None, optional +// The character used to denote the start and end of a quoted item. +// Occurrences of the delimiter or comment characters are ignored within +// a quoted item. The default value is ``quotechar=None``, which means +// quoting support is disabled. +// +// If two consecutive instances of `quotechar` are found within a quoted +// field, the first is treated as an escape character. See examples. +// +// .. versionadded:: 1.23.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Data read from the text file. +// +// See Also +// -------- +// load, fromstring, fromregex +// genfromtxt : Load data with missing values handled as specified. +// scipy.io.loadmat : reads MATLAB data files +// +// Notes +// ----- +// This function aims to be a fast reader for simply formatted files. The +// `genfromtxt` function provides more sophisticated handling of, e.g., +// lines with missing values. +// +// Each row in the input text file must have the same number of values to be +// able to read all values. If all rows do not have same number of values, a +// subset of up to n columns (where n is the least number of values present +// in all rows) can be read by specifying the columns via `usecols`. +// +// .. versionadded:: 1.10.0 +// +// The strings produced by the Python float.hex method can be used as +// input for floats. +// +// Examples +// -------- +// >>> from io import StringIO # StringIO behaves like a file object +// >>> c = StringIO("0 1\n2 3") +// >>> np.loadtxt(c) +// array([[0., 1.], +// [2., 3.]]) +// +// >>> d = StringIO("M 21 72\nF 35 58") +// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), +// ... 'formats': ('S1', 'i4', 'f4')}) +// array([(b'M', 21, 72.), (b'F', 35, 58.)], +// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") +// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) +// >>> x +// array([1., 3.]) +// >>> y +// array([2., 4.]) +// +// The `converters` argument is used to specify functions to preprocess the +// text prior to parsing. `converters` can be a dictionary that maps +// preprocessing functions to each column: +// +// >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n") +// >>> conv = { +// ... 0: lambda x: np.floor(float(x)), # conversion fn for column 0 +// ... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1 +// ... } +// >>> np.loadtxt(s, delimiter=",", converters=conv) +// array([[1., 3.], +// [3., 5.]]) +// +// `converters` can be a callable instead of a dictionary, in which case it +// is applied to all columns: +// +// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") +// >>> import functools +// >>> conv = functools.partial(int, base=16) +// >>> np.loadtxt(s, converters=conv) +// array([[222., 173.], +// [192., 222.]]) +// +// This example shows how `converters` can be used to convert a field +// with a trailing minus sign into a negative number. +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> def conv(fld): +// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) +// ... +// >>> np.loadtxt(s, converters=conv) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Using a callable as the converter can be particularly useful for handling +// values with different formatting, e.g. floats with underscores: +// +// >>> s = StringIO("1 2.7 100_000") +// >>> np.loadtxt(s, converters=float) +// array([1.e+00, 2.7e+00, 1.e+05]) +// +// This idea can be extended to automatically handle values specified in +// many different formats: +// +// >>> def conv(val): +// ... try: +// ... return float(val) +// ... except ValueError: +// ... return float.fromhex(val) +// >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2") +// >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None) +// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) +// +// Note that with the default ``encoding="bytes"``, the inputs to the +// converter function are latin-1 encoded byte strings. To deactivate the +// implicit encoding prior to conversion, use ``encoding=None`` +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x) +// >>> np.loadtxt(s, converters=conv, encoding=None) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Support for quoted fields is enabled with the `quotechar` parameter. +// Comment and delimiter characters are ignored when they appear within a +// quoted item delineated by `quotechar`: +// +// >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// dtype=[('label', '>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"') +// >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"') +// array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20") +// >>> np.loadtxt(d, usecols=(0, 1)) +// array([[ 1., 2.], +// [ 2., 4.], +// [ 3., 9.], +// [ 4., 16.]]) +// +// +// +//go:linkname Loadtxt py.loadtxt +func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object +// +// Load data from a text file, with missing values handled as specified. +// +// Each line past the first `skip_header` lines is split at the `delimiter` +// character, and characters following the `comments` character are discarded. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : dtype, optional +// Data type of the resulting array. +// If None, the dtypes will be determined by the contents of each +// column, individually. +// comments : str, optional +// The character used to indicate the start of a comment. +// All the characters occurring on a line after a comment are discarded. +// delimiter : str, int, or sequence, optional +// The string used to separate values. By default, any consecutive +// whitespaces act as delimiter. An integer or sequence of integers +// can also be provided as width(s) of each field. +// skiprows : int, optional +// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. +// skip_header : int, optional +// The number of lines to skip at the beginning of the file. +// skip_footer : int, optional +// The number of lines to skip at the end of the file. +// converters : variable, optional +// The set of functions that convert the data of a column to a value. +// The converters can also be used to provide a default value +// for missing data: ``converters = {3: lambda s: float(s or 0)}``. +// missing : variable, optional +// `missing` was removed in numpy 1.10. Please use `missing_values` +// instead. +// missing_values : variable, optional +// The set of strings corresponding to missing data. +// filling_values : variable, optional +// The set of values to be used as default when the data are missing. +// usecols : sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. +// names : {None, True, str, sequence}, optional +// If `names` is True, the field names are read from the first line after +// the first `skip_header` lines. This line can optionally be preceded +// by a comment delimiter. If `names` is a sequence or a single-string of +// comma-separated names, the names will be used to define the field names +// in a structured dtype. If `names` is None, the names of the dtype +// fields will be used, if any. +// excludelist : sequence, optional +// A list of names to exclude. This list is appended to the default list +// ['return','file','print']. Excluded names are appended with an +// underscore: for example, `file` would become `file_`. +// deletechars : str, optional +// A string combining invalid characters that must be deleted from the +// names. +// defaultfmt : str, optional +// A format used to define default field names, such as "f%i" or "f_%02i". +// autostrip : bool, optional +// Whether to automatically strip white spaces from the variables. +// replace_space : char, optional +// Character(s) used in replacement of white spaces in the variable +// names. By default, use a '_'. +// case_sensitive : {True, False, 'upper', 'lower'}, optional +// If True, field names are case sensitive. +// If False or 'upper', field names are converted to upper case. +// If 'lower', field names are converted to lower case. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = genfromtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// usemask : bool, optional +// If True, return a masked array. +// If False, return a regular array. +// loose : bool, optional +// If True, do not raise errors for invalid values. +// invalid_raise : bool, optional +// If True, an exception is raised if an inconsistency is detected in the +// number of columns. +// If False, a warning is emitted and the offending lines are skipped. +// max_rows : int, optional +// The maximum number of rows to read. Must not be used with skip_footer +// at the same time. If given, the value must be at least 1. Default is +// to read the entire file. +// +// .. versionadded:: 1.10.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply when `fname` is +// a file object. The special value 'bytes' enables backward compatibility +// workarounds that ensure that you receive byte arrays when possible +// and passes latin1 encoded strings to converters. Override this value to +// receive unicode arrays and pass strings as input to converters. If set +// to None the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// ndmin : int, optional +// Same parameter as `loadtxt` +// +// .. versionadded:: 1.23.0 +// like : array_like, optional +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Data read from the text file. If `usemask` is True, this is a +// masked array. +// +// See Also +// -------- +// numpy.loadtxt : equivalent function when no data is missing. +// +// Notes +// ----- +// * When spaces are used as delimiters, or when no delimiter has been given +// as input, there should not be any missing data between two fields. +// * When the variables are named (either by a flexible dtype or with `names`), +// there must not be any header in the file (else a ValueError +// exception is raised). +// * Individual values are not stripped of spaces by default. +// When using a custom converter, make sure the function does remove spaces. +// +// References +// ---------- +// .. [1] NumPy User Guide, section `I/O with NumPy +// `_. +// +// Examples +// -------- +// >>> from io import StringIO +// >>> import numpy as np +// +// Comma delimited file with mixed dtype +// +// >>> s = StringIO(u"1,1.3,abcde") +// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), +// ... ('mystring','S5')], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only +// >>> data = np.genfromtxt(s, dtype=None, +// ... names = ['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) +// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", +// ... names=['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> s = StringIO(u"11.3abcde") +// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], +// ... delimiter=[1,3,5]) +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('intvar', '>> f = StringIO(''' +// ... text,# of chars +// ... hello world,11 +// ... numpy,5''') +// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') +// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], +// dtype=[('f0', 'S12'), ('f1', 'S12')]) +// +// +// +//go:linkname Genfromtxt py.genfromtxt +func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object +// +// Load ASCII data from a file and return it in a record array. +// +// If ``usemask=False`` a standard `recarray` is returned, +// if ``usemask=True`` a MaskedRecords array is returned. +// +// Parameters +// ---------- +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromtxt py.recfromtxt +func Recfromtxt(fname *py.Object) *py.Object +// +// Load ASCII data stored in a comma-separated file. +// +// The returned array is a record array (if ``usemask=False``, see +// `recarray`) or a masked record array (if ``usemask=True``, +// see `ma.mrecords.MaskedRecords`). +// +// Parameters +// ---------- +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function to load ASCII data. +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromcsv py.recfromcsv +func Recfromcsv(fname *py.Object) *py.Object +// +// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. +// +// .. warning:: Loading files that contain object arrays uses the ``pickle`` +// module, which is not secure against erroneous or maliciously +// constructed data. Consider passing ``allow_pickle=False`` to +// load data that is known not to contain object arrays for the +// safer handling of untrusted sources. +// +// Parameters +// ---------- +// file : file-like object, string, or pathlib.Path +// The file to read. File-like objects must support the +// ``seek()`` and ``read()`` methods and must always +// be opened in binary mode. Pickled files require that the +// file-like object support the ``readline()`` method as well. +// mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional +// If not None, then memory-map the file, using the given mode (see +// `numpy.memmap` for a detailed description of the modes). A +// memory-mapped array is kept on disk. However, it can be accessed +// and sliced like any ndarray. Memory mapping is especially useful +// for accessing small fragments of large files without reading the +// entire file into memory. +// allow_pickle : bool, optional +// Allow loading pickled object arrays stored in npy files. Reasons for +// disallowing pickles include security, as loading pickled data can +// execute arbitrary code. If pickles are disallowed, loading object +// arrays will fail. Default: False +// +// .. versionchanged:: 1.16.3 +// Made default False in response to CVE-2019-6446. +// +// fix_imports : bool, optional +// Only useful when loading Python 2 generated pickled files on Python 3, +// which includes npy/npz files containing object arrays. If `fix_imports` +// is True, pickle will try to map the old Python 2 names to the new names +// used in Python 3. +// encoding : str, optional +// What encoding to use when reading Python 2 strings. Only useful when +// loading Python 2 generated pickled files in Python 3, which includes +// npy/npz files containing object arrays. Values other than 'latin1', +// 'ASCII', and 'bytes' are not allowed, as they can corrupt numerical +// data. Default: 'ASCII' +// max_header_size : int, optional +// Maximum allowed size of the header. Large headers may not be safe +// to load securely and thus require explicitly passing a larger value. +// See :py:func:`ast.literal_eval()` for details. +// This option is ignored when `allow_pickle` is passed. In that case +// the file is by definition trusted and the limit is unnecessary. +// +// Returns +// ------- +// result : array, tuple, dict, etc. +// Data stored in the file. For ``.npz`` files, the returned instance +// of NpzFile class must be closed to avoid leaking file descriptors. +// +// Raises +// ------ +// OSError +// If the input file does not exist or cannot be read. +// UnpicklingError +// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. +// ValueError +// The file contains an object array, but ``allow_pickle=False`` given. +// EOFError +// When calling ``np.load`` multiple times on the same file handle, +// if all data has already been read +// +// See Also +// -------- +// save, savez, savez_compressed, loadtxt +// memmap : Create a memory-map to an array stored in a file on disk. +// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. +// +// Notes +// ----- +// - If the file contains pickle data, then whatever object is stored +// in the pickle is returned. +// - If the file is a ``.npy`` file, then a single array is returned. +// - If the file is a ``.npz`` file, then a dictionary-like object is +// returned, containing ``{filename: array}`` key-value pairs, one for +// each file in the archive. +// - If the file is a ``.npz`` file, the returned value supports the +// context manager protocol in a similar fashion to the open function:: +// +// with load('foo.npz') as data: +// a = data['a'] +// +// The underlying file descriptor is closed when exiting the 'with' +// block. +// +// Examples +// -------- +// Store data to disk, and load it again: +// +// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) +// >>> np.load('/tmp/123.npy') +// array([[1, 2, 3], +// [4, 5, 6]]) +// +// Store compressed data to disk, and load it again: +// +// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) +// >>> b=np.array([1, 2]) +// >>> np.savez('/tmp/123.npz', a=a, b=b) +// >>> data = np.load('/tmp/123.npz') +// >>> data['a'] +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> data['b'] +// array([1, 2]) +// >>> data.close() +// +// Mem-map the stored array, and then access the second row +// directly from disk: +// +// >>> X = np.load('/tmp/123.npy', mmap_mode='r') +// >>> X[1, :] +// memmap([4, 5, 6]) +// +// +// +//go:linkname Load py.load +func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object +// +// Construct an array from a text file, using regular expression parsing. +// +// The returned array is always a structured array, and is constructed from +// all matches of the regular expression in the file. Groups in the regular +// expression are converted to fields of the structured array. +// +// Parameters +// ---------- +// file : path or file +// Filename or file object to read. +// +// .. versionchanged:: 1.22.0 +// Now accepts `os.PathLike` implementations. +// regexp : str or regexp +// Regular expression used to parse the file. +// Groups in the regular expression correspond to fields in the dtype. +// dtype : dtype or list of dtypes +// Dtype for the structured array; must be a structured datatype. +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply to input streams. +// +// .. versionadded:: 1.14.0 +// +// Returns +// ------- +// output : ndarray +// The output array, containing the part of the content of `file` that +// was matched by `regexp`. `output` is always a structured array. +// +// Raises +// ------ +// TypeError +// When `dtype` is not a valid dtype for a structured array. +// +// See Also +// -------- +// fromstring, loadtxt +// +// Notes +// ----- +// Dtypes for structured arrays can be specified in several forms, but all +// forms specify at least the data type and field name. For details see +// `basics.rec`. +// +// Examples +// -------- +// >>> from io import StringIO +// >>> text = StringIO("1312 foo\n1534 bar\n444 qux") +// +// >>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything] +// >>> output = np.fromregex(text, regexp, +// ... [('num', np.int64), ('key', 'S3')]) +// >>> output +// array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')], +// dtype=[('num', '>> output['num'] +// array([1312, 1534, 444]) +// +// +// +//go:linkname Fromregex py.fromregex +func Fromregex(file *py.Object, regexp *py.Object, dtype *py.Object, encoding *py.Object) *py.Object +// +// Build a matrix object from a string, nested sequence, or array. +// +// Parameters +// ---------- +// obj : str or array_like +// Input data. If a string, variables in the current scope may be +// referenced by name. +// ldict : dict, optional +// A dictionary that replaces local operands in current frame. +// Ignored if `obj` is not a string or `gdict` is None. +// gdict : dict, optional +// A dictionary that replaces global operands in current frame. +// Ignored if `obj` is not a string. +// +// Returns +// ------- +// out : matrix +// Returns a matrix object, which is a specialized 2-D array. +// +// See Also +// -------- +// block : +// A generalization of this function for N-d arrays, that returns normal +// ndarrays. +// +// Examples +// -------- +// >>> A = np.mat('1 1; 1 1') +// >>> B = np.mat('2 2; 2 2') +// >>> C = np.mat('3 4; 5 6') +// >>> D = np.mat('7 8; 9 0') +// +// All the following expressions construct the same block matrix: +// +// >>> np.bmat([[A, B], [C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat('A,B; C,D') +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// +// +// +//go:linkname Bmat py.bmat +func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. +// +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Mat py.mat +func Mat(data *py.Object, dtype *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. +// +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Asmatrix py.asmatrix +func Asmatrix(data *py.Object, dtype *py.Object) *py.Object +// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Calculate the absolute value element-wise. +// +// ``np.abs`` is a shorthand for this function. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// 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. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// absolute : ndarray +// An ndarray containing the absolute value of +// each element in `x`. For complex input, ``a + ib``, the +// absolute value is :math:`\sqrt{ a^2 + b^2 }`. +// This is a scalar if `x` is a scalar. +// +// Examples +// -------- +// >>> x = np.array([-1.2, 1.2]) +// >>> np.absolute(x) +// array([ 1.2, 1.2]) +// >>> np.absolute(1.2 + 1j) +// 1.5620499351813308 +// +// Plot the function over ``[-10, 10]``: +// +// >>> import matplotlib.pyplot as plt +// +// >>> x = np.linspace(start=-10, stop=10, num=101) +// >>> plt.plot(x, np.absolute(x)) +// >>> plt.show() +// +// Plot the function over the complex plane: +// +// >>> xx = x + 1j * x[:, np.newaxis] +// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') +// >>> plt.show() +// +// The `abs` function can be used as a shorthand for ``np.absolute`` on +// ndarrays. +// +// >>> x = np.array([-1.2, 1.2]) +// >>> abs(x) +// array([1.2, 1.2]) +// +//go:linkname Abs py.abs +func Abs(__llgo_va_list ...interface{}) *py.Object diff --git a/numpy/numpy_autogen_link.go b/numpy/numpy_autogen_link.go new file mode 100644 index 00000000..bb5882ce --- /dev/null +++ b/numpy/numpy_autogen_link.go @@ -0,0 +1,5 @@ +package numpy + +import _ "github.com/goplus/lib/py" + +// LLGoPackage is defined in the main binding file