diff --git a/Numpy.NET.sln b/Numpy.NET.sln index 660a54d..a0a1c92 100644 --- a/Numpy.NET.sln +++ b/Numpy.NET.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 16 -VisualStudioVersion = 16.0.30503.244 +# Visual Studio Version 17 +VisualStudioVersion = 17.4.33103.184 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Numpy", "src\Numpy\Numpy.csproj", "{D527C885-AD64-4499-9E92-F9A543C0D14B}" EndProject @@ -33,7 +33,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Numpy.Bare.Dotnet", "src\Nu EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WebApiExample_netcore3.1", "src\Examples\WebApiExample_netcore3.1\WebApiExample_netcore3.1.csproj", "{53C73261-DD84-47D1-A9BA-E553D34FF0A3}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CustomInstallLocationExample", "src\Examples\CustomInstallLocationExample\CustomInstallLocationExample.csproj", "{BB0A367A-8A36-454F-9F92-2FD6DA665A39}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CustomInstallLocationExample", "src\Examples\CustomInstallLocationExample\CustomInstallLocationExample.csproj", "{BB0A367A-8A36-454F-9F92-2FD6DA665A39}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SlicingExample", "src\Examples\SlicingExample\SlicingExample.csproj", "{FB116716-8C1F-4926-86F9-03AE46C7FA58}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WpfExample", "WpfExample\WpfExample.csproj", "{BF447620-877B-4000-BF75-527AEF94F347}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -101,6 +105,14 @@ Global {BB0A367A-8A36-454F-9F92-2FD6DA665A39}.Debug|Any CPU.Build.0 = Debug|Any CPU {BB0A367A-8A36-454F-9F92-2FD6DA665A39}.Release|Any CPU.ActiveCfg = Release|Any CPU {BB0A367A-8A36-454F-9F92-2FD6DA665A39}.Release|Any CPU.Build.0 = Release|Any CPU + {FB116716-8C1F-4926-86F9-03AE46C7FA58}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {FB116716-8C1F-4926-86F9-03AE46C7FA58}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FB116716-8C1F-4926-86F9-03AE46C7FA58}.Release|Any CPU.ActiveCfg = Release|Any CPU + {FB116716-8C1F-4926-86F9-03AE46C7FA58}.Release|Any CPU.Build.0 = Release|Any CPU + {BF447620-877B-4000-BF75-527AEF94F347}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BF447620-877B-4000-BF75-527AEF94F347}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BF447620-877B-4000-BF75-527AEF94F347}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BF447620-877B-4000-BF75-527AEF94F347}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -112,6 +124,8 @@ Global {84BCB8CA-6B29-48D8-BEEE-751C7547419E} = {25D84E98-E107-45C9-A0EC-0B25E24DA607} {53C73261-DD84-47D1-A9BA-E553D34FF0A3} = {25D84E98-E107-45C9-A0EC-0B25E24DA607} {BB0A367A-8A36-454F-9F92-2FD6DA665A39} = {25D84E98-E107-45C9-A0EC-0B25E24DA607} + {FB116716-8C1F-4926-86F9-03AE46C7FA58} = {25D84E98-E107-45C9-A0EC-0B25E24DA607} + {BF447620-877B-4000-BF75-527AEF94F347} = {25D84E98-E107-45C9-A0EC-0B25E24DA607} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {5EB08541-5168-443C-B524-A5CB7E7C613D} diff --git a/README.md b/README.md index 9a5e69b..9fb44ef 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,7 @@ In other cases, you might want to control the install location of the Python ins ## How does it work? -Numpy.NET uses [Python for .NET](http://pythonnet.github.io/) to call into the Python module `numpy`. However, this does not mean that it depends on a local Python installation! Numpy.NET.dll uses [Python.Included](https://github.com/henon/Python.Included) which packages embedded Python 3.7 and automatically deploys it in the user's home directory upon first execution. On subsequent runs, it will find Python already deployed and therefor doesn't install it again. Numpy.NET also packages the NumPy wheel and installs it into the embedded Python installation when not yet installed. +Numpy.NET uses [Python for .NET](http://pythonnet.github.io/) to call into the Python module `numpy`. However, this does not mean that it depends on a local Python installation! Numpy.NET.dll uses [Python.Included](https://github.com/henon/Python.Included) which packages embedded Python 3.7 and automatically deploys it in the user's home directory upon first execution. On subsequent runs, it will find Python already deployed and therefore doesn't install it again. Numpy.NET also packages the NumPy wheel and installs it into the embedded Python installation when not yet installed. Long story short: as a .NET Developer **you don't need to worry about Python** at all. You just reference Numpy.NET, use it and **it will just work**, no matter if you have local Python installations or not. diff --git a/WpfExample/App.xaml b/WpfExample/App.xaml new file mode 100644 index 0000000..8bcbf4d --- /dev/null +++ b/WpfExample/App.xaml @@ -0,0 +1,9 @@ + + + + + diff --git a/WpfExample/App.xaml.cs b/WpfExample/App.xaml.cs new file mode 100644 index 0000000..66421cb --- /dev/null +++ b/WpfExample/App.xaml.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Configuration; +using System.Data; +using System.Linq; +using System.Threading.Tasks; +using System.Windows; + +namespace WpfExample +{ + + public partial class App : Application + { + + } +} diff --git a/WpfExample/AssemblyInfo.cs b/WpfExample/AssemblyInfo.cs new file mode 100644 index 0000000..74087a1 --- /dev/null +++ b/WpfExample/AssemblyInfo.cs @@ -0,0 +1,10 @@ +using System.Windows; + +[assembly: ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] diff --git a/WpfExample/MainWindow.xaml b/WpfExample/MainWindow.xaml new file mode 100644 index 0000000..82bf2e4 --- /dev/null +++ b/WpfExample/MainWindow.xaml @@ -0,0 +1,17 @@ + + + + + + Run the blocking example first, then the non-blocking example will be activated. + + + + diff --git a/WpfExample/MainWindow.xaml.cs b/WpfExample/MainWindow.xaml.cs new file mode 100644 index 0000000..a5e2290 --- /dev/null +++ b/WpfExample/MainWindow.xaml.cs @@ -0,0 +1,88 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Navigation; +using System.Windows.Shapes; +using Numpy; +using Python.Runtime; + +namespace WpfExample +{ + + public partial class MainWindow : Window + { + public MainWindow() + { + InitializeComponent(); + } + + private bool _allowThreads = false; + + private void WriteLine(string text) + { + TextBox.AppendText(text + "\n"); + TextBox.ScrollToEnd(); + } + + private void OnBlockingClick(object sender, RoutedEventArgs e) + { + WriteLine("Example 1: Matrix multiplication with NumPy on the GUI thread (blocking):"); + // before starting the measurement, let us call numpy once to get the setup checks done. + np.arange(1); + var stopwatch = Stopwatch.StartNew(); + + var a1 = np.arange(60000).reshape(300, 200); + var a2 = np.arange(80000).reshape(200, 400); + + var result = np.matmul(a1, a2); + stopwatch.Stop(); + + WriteLine($"execution time with NumPy: {stopwatch.Elapsed.TotalMilliseconds}ms\n"); + WriteLine("Result:\n" + result.repr); + WriteLine("\nNote: blocking usage is not recommended. "); + WriteLine("\nIf you close the program without runnning example 2 it will hang indefinitely. "); + Button1.IsEnabled = false; + Button2.IsEnabled = true; + } + + private async void OnNonBlockingClick(object sender, RoutedEventArgs e) + { + WriteLine("Example 2: Matrix multiplication with NumPy on a background thread (non-blocking):"); + + if (!_allowThreads) { + // https://github.com/pythonnet/pythonnet/issues/109 + PythonEngine.BeginAllowThreads(); + _allowThreads=true; + } + var stopwatch = Stopwatch.StartNew(); + var resultString = ""; + await Task.Run(() => { + using (Py.GIL()) { + + + var a1 = np.arange(60000).reshape(300, 200); + var a2 = np.arange(80000).reshape(200, 400); + + var result = np.matmul(a1, a2); + stopwatch.Stop(); + resultString = result.repr; + } + }); + await this.Dispatcher.BeginInvoke(() => { + WriteLine($"execution time with NumPy: {stopwatch.Elapsed.TotalMilliseconds}ms\n"); + WriteLine("Result:\n" + resultString); + }); + WriteLine("\nNote: if you close the program now it will not hang because of PythonEngine.BeginAllowThreads();\nWe only have to make sure to enclose all calculations in using(Py.GIL()) { }"); + } + } +} diff --git a/WpfExample/WpfExample.csproj b/WpfExample/WpfExample.csproj new file mode 100644 index 0000000..475c825 --- /dev/null +++ b/WpfExample/WpfExample.csproj @@ -0,0 +1,14 @@ + + + + WinExe + net6.0-windows + enable + true + + + + + + + diff --git a/src/CodeMinion.ApiGenerator/NumPy/ApiGenerator.cs b/src/CodeMinion.ApiGenerator/NumPy/ApiGenerator.cs index 3e7aff8..5709388 100644 --- a/src/CodeMinion.ApiGenerator/NumPy/ApiGenerator.cs +++ b/src/CodeMinion.ApiGenerator/NumPy/ApiGenerator.cs @@ -252,6 +252,15 @@ public string Generate() var window_api = new StaticApi() { PartialName = "window", StaticName = "np", ImplName = "NumPy", PythonModule = "numpy", }; _generator.StaticApis.Add(window_api); ParseNumpyApi(window_api, "routines.window.html"); + // ---------------------------------------------------- + // Other functions + // ---------------------------------------------------- + var other_api = new StaticApi() { PartialName = "other", StaticName = "np", ImplName = "NumPy", PythonModule = "numpy", }; + _generator.StaticApis.Add(other_api); + var links = new[]{ + "numpy.roots.html" + }; + ParseSinglePages(other_api, links); // ---------------------------------------------------- // generate Numpy @@ -357,71 +366,89 @@ private void ParseNumpyApi(StaticApi api, string link) _generator.TestFiles.Add(testfile); foreach (var html_doc in docs) { - var doc = html_doc.Doc; - // declaration - var h1 = doc.DocumentNode.Descendants("h1").FirstOrDefault(); - if (h1 == null) - continue; - var dl = doc.DocumentNode.Descendants("dl").FirstOrDefault(); - //if (dl == null || dl.Attributes["class"]?.Value != "function") continue; - var class_name = doc.DocumentNode.Descendants("code").FirstOrDefault(x => x.Attributes["class"]?.Value == "descclassname")?.InnerText; - if (class_name == null) - continue; - var func_name = doc.DocumentNode.Descendants("code") - .First(x => x.Attributes["class"]?.Value == "descname").InnerText; - if (parsed_api_functions.Contains(class_name + "." + func_name)) - continue; - parsed_api_functions.Add(class_name + "." + func_name); - var decl = new Function() { Tag = link, Name = func_name, ClassName = class_name.TrimEnd('.') }; - // function description - var dd = dl.Descendants("dd").FirstOrDefault(); - decl.Description = ParseDescription(dd); - var table = doc.DocumentNode.Descendants("table") - .FirstOrDefault(x => x.Attributes["class"]?.Value == "docutils field-list"); - if (table == null) - continue; - //if (decl.Name == "copyto") - // Debugger.Break(); - // arguments - ParseArguments(html_doc, table, decl); + ParseNumpyDocPage(api, link, html_doc, testfile); + } + } - // return type(s) - ParseReturnTypes(html_doc, table, decl); + private void ParseSinglePages(StaticApi api, params string[] links) + { + var docs = links.Select(x=>GetHtml("generated/"+x)); + var testfile = new TestFile() { Name = $"{api.ImplName}_{api.PartialName}" }; + _generator.TestFiles.Add(testfile); + foreach (var html_doc in docs) + { + ParseNumpyDocPage(api, "single pages", html_doc, testfile); + } + } - PostProcess(decl); - if (!decl.CommentOut) - _function_count++; + private void ParseNumpyDocPage(StaticApi api, string link, HtmlDoc html_doc, TestFile testfile) + { + var doc = html_doc.Doc; + // declaration + var h1 = doc.DocumentNode.Descendants("h1").FirstOrDefault(); + if (h1 == null) + return; + var dl = doc.DocumentNode.Descendants("dl").FirstOrDefault(); + //if (dl == null || dl.Attributes["class"]?.Value != "function") continue; + var class_name = doc.DocumentNode.Descendants("code") + .FirstOrDefault(x => x.Attributes["class"]?.Value == "descclassname")?.InnerText; + if (class_name == null) + return; + var func_name = doc.DocumentNode.Descendants("code") + .First(x => x.Attributes["class"]?.Value == "descname").InnerText; + if (parsed_api_functions.Contains(class_name + "." + func_name)) + return; + parsed_api_functions.Add(class_name + "." + func_name); + var decl = new Function() { Tag = link, Name = func_name, ClassName = class_name.TrimEnd('.') }; + // function description + var dd = dl.Descendants("dd").FirstOrDefault(); + decl.Description = ParseDescription(dd); + var table = doc.DocumentNode.Descendants("table") + .FirstOrDefault(x => x.Attributes["class"]?.Value == "docutils field-list"); + if (table == null) + return; + //if (decl.Name == "copyto") + // Debugger.Break(); + // arguments + ParseArguments(html_doc, table, decl); - // if necessary create overloads - foreach (var d in InferOverloads(decl)) + // return type(s) + ParseReturnTypes(html_doc, table, decl); + + PostProcess(decl); + if (!decl.CommentOut) + _function_count++; + + // if necessary create overloads + foreach (var d in InferOverloads(decl)) + { + PostProcessOverloads(d); + api.Declarations.Add(d); + // if this is an ndarray member, add it to the dynamic api also + if (ndarray_api != null && d.Arguments.FirstOrDefault()?.Type == "NDarray" && class_name == "numpy.") { - PostProcessOverloads(d); - api.Declarations.Add(d); - // if this is an ndarray member, add it to the dynamic api also - if (ndarray_api != null && d.Arguments.FirstOrDefault()?.Type == "NDarray" && class_name == "numpy.") + switch (decl.Name) { - switch (decl.Name) - { - // do not add to NDArray instance methods - case "copyto": - case "transpose": - case "amax": - case "amin": - case "real": - case "imag": - continue; - } - var dc = d.Clone(); - dc.Arguments.RemoveAt(0); - //dc.ForwardToStaticImpl = "NumPy.Instance"; - ndarray_api.Declarations.Add(dc); + // do not add to NDArray instance methods + case "copyto": + //case "transpose": + //case "amax": + //case "amin": + //case "real": + //case "imag": + continue; } + decl.IsExtensionFunction = true; + //var dc = d.Clone(); + //dc.Arguments.RemoveAt(0); + //ndarray_api.Declarations.Add(dc); } - // see if there are any examples which we can convert to test cases - var testcase = ParseTests(doc, decl); - if (testcase != null) - testfile.TestCases.Add(testcase); } + + // see if there are any examples which we can convert to test cases + var testcase = ParseTests(doc, decl); + if (testcase != null) + testfile.TestCases.Add(testcase); } private TestCase ParseTests(HtmlDocument doc, Function decl) @@ -655,6 +682,8 @@ private void PostProcess(Function decl) case "tobytes": case "view": case "resize": + case "insert": + case "einsum": decl.ManualOverride = true; // do not generate an implementation break; case "arange": @@ -718,23 +747,11 @@ private void PostProcess(Function decl) case "correlate": decl.Arguments.Remove(decl.Arguments.FirstOrDefault(x => x.Name == "old_behavior")); break; - case "einsum": - var optimize = decl.Arguments.First(x => x.Name == "optimize"); - optimize.Type = "object"; - optimize.DefaultValue = "null"; - optimize.DefaultIfNull = "false"; - break; case "rot90": var axes = decl.Arguments.First(x => x.Name == "axes"); axes.DefaultValue = "null"; axes.DefaultIfNull = "new int[] {0, 1}"; break; - case "insert": - var obj = decl.Arguments.First(x => x.Name == "obj"); - obj.DefaultValue = "0"; - var values = decl.Arguments.First(x => x.Name == "values"); - values.DefaultValue = "null"; - break; case "trapz": var dx = decl.Arguments.First(x => x.Name == "dx"); dx.Type = "float"; @@ -894,6 +911,7 @@ private IEnumerable InferOverloads(Function decl) { switch (decl.Name) { + case "qr": case "norm": case "asscalar": case "normal": @@ -1119,16 +1137,12 @@ private IEnumerable InferOverloads(Function decl) else yield return decl; yield break; - //case "meshgrid": - // yield return decl; - // yield return decl.Clone(f => - // { - // f.Arguments[0].Type = "params NDarray[]"; - // f.Arguments.RemoveAt(1); - // f.Arguments.RemoveAt(1); - // f.Arguments.RemoveAt(1); - // }); - // yield break; + case "gradient": // don't generate. + yield break; + case "split": + yield return decl; + yield return decl.Clone(f => { f.Arguments[1].Type = "int"; }); + yield break; } // without args we don't need to consider possible overloads @@ -1542,7 +1556,8 @@ HtmlDoc GetHtml(string relative_url) doc.Doc = new HtmlDocument(); doc.Doc.Load(doc.Filename); doc.Text = doc.Doc.Text; - return doc; + if (!doc.Text.Contains("404 Not Found")) + return doc; } var web = new HtmlWeb(); doc.Doc = web.Load(BaseUrl + relative_url); diff --git a/src/CodeMinion.ApiGenerator/NumPy/SpecialGenerators.cs b/src/CodeMinion.ApiGenerator/NumPy/SpecialGenerators.cs index d44b3b1..c020112 100644 --- a/src/CodeMinion.ApiGenerator/NumPy/SpecialGenerators.cs +++ b/src/CodeMinion.ApiGenerator/NumPy/SpecialGenerators.cs @@ -8,7 +8,7 @@ public static class SpecialGenerators public static void InitNumpyGenerator(CodeWriter s) { s.Out("#if PYTHON_INCLUDED"); - s.Out("Installer.InstallWheel(typeof(np).Assembly, \"numpy-1.16.3-cp37-cp37m-win_amd64.whl\").Wait();"); + s.Out("Installer.InstallWheel(typeof(np).Assembly, \"numpy-1.23.5-cp311-cp311-win_amd64.whl\", force).Wait();"); s.Out("#endif"); } diff --git a/src/CodeMinion.Core/CodeGenerator.cs b/src/CodeMinion.Core/CodeGenerator.cs index 71913c9..ab2017a 100644 --- a/src/CodeMinion.Core/CodeGenerator.cs +++ b/src/CodeMinion.Core/CodeGenerator.cs @@ -90,7 +90,7 @@ protected virtual void GenerateApiFunction(Declaration decl, CodeWriter s, bool var prefix_str = ""; if (prefix && levels > 0) prefix_str = string.Join("_", class_names.Skip(1)) + "_"; - s.Out($"public {(@static ? "static ":"")}{retval} {EscapeName(prefix_str + decl.Name)}{func.SharpOnlyPostfix}{generics}({arguments})"); + s.Out($"public {(@static ? "static ":"")}{retval} {EscapeName(prefix_str + decl.Name)}{func.SharpOnlyPostfix}{generics}({(@static && func.IsExtensionFunction ? "this " : "")}{arguments})"); s.Block(() => { GenerateFunctionBody(func, s, prefix_str); @@ -596,7 +596,8 @@ public virtual void GenerateDynamicApi(DynamicApi api, CodeWriter s) { if (decl.ManualOverride || decl.Ignore) continue; - GenerateApiFunction(decl, s); + if (decl is Function && !(decl as Function).IsExtensionFunction) + GenerateApiFunction(decl, s); } catch (Exception e) { @@ -900,10 +901,15 @@ private void GenerateStaticModuleHead(CodeWriter s) { s.Out($"public static partial class {StaticModuleName}", () => { + s.Out("static np()", () => + { + s.Out("ReInitializeLazySelf();"); + }); s.Break(); s.Out("public static PyObject self => _lazy_self.Value;"); s.Break(); - s.Out($"private static Lazy _lazy_self = new Lazy(() => ", () => + s.Out($"private static Lazy _lazy_self = default;"); + s.Out($"private static void ReInitializeLazySelf() => _lazy_self = new Lazy(() => ", () => { s.Out("try", () => { @@ -925,6 +931,7 @@ private void GenerateStaticModuleHead(CodeWriter s) s.Out(@"#endif"); foreach (var generator in InitializationGenerators) generator(s); + s.Out("PythonEngine.AddShutdownHandler(() => ReInitializeLazySelf());"); s.Out("PythonEngine.Initialize();"); s.Out($"var mod = Py.Import(\"{PythonModuleName}\");"); s.Out("return mod;"); @@ -987,7 +994,7 @@ private void GenToCsharp(CodeWriter s, bool @static = false) { s.Break(); s.Out("//auto-generated"); - s.Out($"{(@static?"private static":"public")} T ToCsharp(dynamic pyobj)", () => + s.Out($"{(@static?"internal static":"public")} T ToCsharp(dynamic pyobj)", () => { s.Out("switch (typeof(T).Name)", () => { @@ -997,11 +1004,13 @@ private void GenToCsharp(CodeWriter s, bool @static = false) s.Out(@case); } s.Out("default:"); + s.Out("var pyClass = $\"{pyobj.__class__}\";"); + s.Out("if (pyClass == \"\")", () => s.Out("return (T)(object)pyobj.ToString();")); + s.Out("if (pyClass.StartsWith(\" s.Out("return (pyobj.item() as PyObject).As();")); s.Out("try", () => s.Out("return pyobj.As();")); s.Out("catch (Exception e)", () => { - s.Out( - "throw new NotImplementedException($\"conversion from {typeof(T).Name} to {pyobj.__class__} not implemented\", e);"); + s.Out("throw new NotImplementedException($\"conversion from {pyobj.__class__} to {typeof(T).Name} not implemented\", e);"); s.Out("return default(T);"); }); }); @@ -1014,14 +1023,14 @@ private void GenToPython(CodeWriter s, bool @static=false) { s.Break(); s.Out("//auto-generated"); - s.Out($"{(@static?"private static":"public")} PyObject ToPython(object obj)", () => + s.Out($"{(@static?"internal static":"public")} PyObject ToPython(object obj)", () => { s.Out("if (obj == null) return Runtime.None;"); s.Out("switch (obj)", () => { s.Out("// basic types"); s.Out("case int o: return new PyInt(o);"); - s.Out("case long o: return new PyLong(o);"); + s.Out("case long o: return new PyInt(o);"); s.Out("case float o: return new PyFloat(o);"); s.Out("case double o: return new PyFloat(o);"); s.Out("case string o: return new PyString(o);"); @@ -1045,7 +1054,7 @@ private void GenSharpToSharp(CodeWriter s, bool @static=false) { s.Break(); s.Out("//auto-generated"); - s.Out($"{(@static ? "private static" : "public")} T SharpToSharp(object obj)", () => + s.Out($"{(@static ? "internal static" : "public")} T SharpToSharp(object obj)", () => { s.Out("if (obj == null) return default(T);"); s.Out("switch (obj)", () => diff --git a/src/CodeMinion.Core/Models/Function.cs b/src/CodeMinion.Core/Models/Function.cs index 75f3ffd..8525999 100644 --- a/src/CodeMinion.Core/Models/Function.cs +++ b/src/CodeMinion.Core/Models/Function.cs @@ -11,6 +11,11 @@ public class Function : Declaration public bool IsConstructor { get; set; } + /// + /// Generate only the static function which also serves as an extension function + /// + public bool IsExtensionFunction { get; set; } = false; + /// /// Generic type parameters of the function /// diff --git a/src/Examples/MatmulExample/MatmulExample.csproj b/src/Examples/MatmulExample/MatmulExample.csproj index 8b979d5..0e842bf 100644 --- a/src/Examples/MatmulExample/MatmulExample.csproj +++ b/src/Examples/MatmulExample/MatmulExample.csproj @@ -6,7 +6,7 @@ - + diff --git a/src/Examples/SlicingExample/Program.cs b/src/Examples/SlicingExample/Program.cs new file mode 100644 index 0000000..ef5073e --- /dev/null +++ b/src/Examples/SlicingExample/Program.cs @@ -0,0 +1,17 @@ +using System; +using Numpy; + +namespace SlicingExample +{ + class Program + { + static void Main(string[] args) + { + var a = np.arange(20).reshape(4,5); + Console.WriteLine(a); + var b = a["2:4"]; + Console.WriteLine("\n sliced with 2:4"); + Console.WriteLine(b ); + } + } +} diff --git a/src/Examples/SlicingExample/SlicingExample.csproj b/src/Examples/SlicingExample/SlicingExample.csproj new file mode 100644 index 0000000..3520e25 --- /dev/null +++ b/src/Examples/SlicingExample/SlicingExample.csproj @@ -0,0 +1,12 @@ + + + + Exe + net5.0 + + + + + + + diff --git a/src/Numpy.Bare.Dotnet/Numpy.Bare.Dotnet.csproj b/src/Numpy.Bare.Dotnet/Numpy.Bare.Dotnet.csproj index b815654..3146206 100644 --- a/src/Numpy.Bare.Dotnet/Numpy.Bare.Dotnet.csproj +++ b/src/Numpy.Bare.Dotnet/Numpy.Bare.Dotnet.csproj @@ -70,12 +70,21 @@ Manual\np.delete.cs + + Manual\np.einsum.cs + + + Manual\np.insert.cs + Manual\np.linalg.norm.cs Manual\np.linspace.cs + + Manual\np.math.cs + Manual\np.meshgrid.cs diff --git a/src/Numpy.Bare/Numpy.Bare.csproj b/src/Numpy.Bare/Numpy.Bare.csproj index fa3edc2..b1c5c8f 100644 --- a/src/Numpy.Bare/Numpy.Bare.csproj +++ b/src/Numpy.Bare/Numpy.Bare.csproj @@ -14,7 +14,7 @@ https://github.com/SciSharp/Numpy.NET Data science, Machine Learning, AI, Scientific Computing, NumPy, Linear Algebra, FFT, SVD, Matrix, Python https://github.com/SciSharp/Numpy.NET/blob/master/LICENSE - 3.7.1.25 + 3.11.1.33 https://github.com/SciSharp/Numpy.NET/blob/master/doc/img/numpy.net.icon128.png?raw=true 3.7.1.4 @@ -37,8 +37,11 @@ + + + @@ -83,8 +86,8 @@ - - + + diff --git a/src/Numpy/Manual/np.array.cs b/src/Numpy/Manual/np.array.cs index 11441ee..b4348b6 100644 --- a/src/Numpy/Manual/np.array.cs +++ b/src/Numpy/Manual/np.array.cs @@ -42,6 +42,7 @@ public static NDarray array(NDarray @object, Dtype dtype = null, bool? copy = nu if (subok != null) kwargs["subok"] = ToPython(subok); if (ndmin != null) kwargs["ndmin"] = ToPython(ndmin); dynamic py = self.InvokeMethod("array", args, kwargs); + args.Dispose(); return ToCsharp(py); } @@ -52,7 +53,8 @@ public static NDarray array(T[] @object, Dtype dtype = null, bool? copy = var ndarray = np.empty(new Shape(@object.Length), dtype: type, order: order); if (@object.Length == 0) return new NDarray(ndarray); - long ptr = ndarray.PyObject.ctypes.data; + var ctypes = ndarray.PyObject.ctypes; + long ptr = ctypes.data; switch ((object)@object) { case char[] a: Marshal.Copy(a, 0, new IntPtr(ptr), a.Length); break; @@ -60,6 +62,7 @@ public static NDarray array(T[] @object, Dtype dtype = null, bool? copy = case short[] a: Marshal.Copy(a, 0, new IntPtr(ptr), a.Length); break; case int[] a: Marshal.Copy(a, 0, new IntPtr(ptr), a.Length); break; case long[] a: Marshal.Copy(a, 0, new IntPtr(ptr), a.Length); break; + //case Half[] a: Marshal.Copy(a, 0, new IntPtr(ptr), a.Length); break; case float[] a: Marshal.Copy(a, 0, new IntPtr(ptr), a.Length); break; case double[] a: Marshal.Copy(a, 0, new IntPtr(ptr), a.Length); break; case bool[] a: @@ -80,8 +83,13 @@ public static NDarray array(T[] @object, Dtype dtype = null, bool? copy = ndarray.imag = ndimag; break; } - if (dtype !=null || subok != null || ndmin != null) - return new NDarray(np.array(ndarray, dtype:dtype, copy: false, subok: subok, ndmin: ndmin)); + ctypes.Dispose(); + if (dtype != null || subok != null || ndmin != null) + { + var converted = np.array(ndarray, dtype: dtype, copy: false, subok: subok, ndmin: ndmin); + ndarray.Dispose(); + return new NDarray(converted); + } return new NDarray(ndarray); } @@ -193,12 +201,7 @@ public static NDarray asarray(ValueType scalar, Dtype dtype = null) /// Scalar representation of a. The output data type is the same type /// returned by the input’s item method. /// - public static T asscalar(NDarray a) - { - if (typeof(T) == typeof(Complex)) - return (T)(object) new Complex(a.real.asscalar(), a.imag.asscalar()); - return self.InvokeMethod("asscalar", a.PyObject).As(); - } + public static T asscalar(NDarray a) => new NDarray(a).item(); // <--- asscalar has been removed as of numpy 1.23 } } diff --git a/src/Numpy/Manual/np.einsum.cs b/src/Numpy/Manual/np.einsum.cs new file mode 100644 index 0000000..29ae966 --- /dev/null +++ b/src/Numpy/Manual/np.einsum.cs @@ -0,0 +1,392 @@ +// Copyright (c) 2021 by Meinrad Recheis (meinrad.recheis@gmail.com) +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using Python.Runtime; +using Numpy.Models; +#if PYTHON_INCLUDED +using Python.Included; +#endif + +namespace Numpy +{ + public static partial class np + { + + /// + /// Evaluates the Einstein summation convention on the operands.

+ /// + /// Using the Einstein summation convention, many common multi-dimensional, + /// linear algebraic array operations can be represented in a simple fashion.

+ /// + /// In implicit mode einsum computes these values.

+ /// + /// In explicit mode, einsum provides further flexibility to compute + /// other array operations that might not be considered classical Einstein + /// summation operations, by disabling, or forcing summation over specified + /// subscript labels.

+ /// + /// See the notes and examples for clarification.

+ /// + /// Notes + /// + /// The Einstein summation convention can be used to compute + /// many multi-dimensional, linear algebraic array operations.

+ /// einsum + /// provides a succinct way of representing these.

+ /// + /// A non-exhaustive list of these operations, + /// which can be computed by einsum, is shown below along with examples: + /// + /// The subscripts string is a comma-separated list of subscript labels, + /// where each label refers to a dimension of the corresponding operand.

+ /// + /// Whenever a label is repeated it is summed, so np.einsum('i,i', a, b) + /// is equivalent to np.inner(a,b).

+ /// If a label + /// appears only once, it is not summed, so np.einsum('i', a) produces a + /// view of a with no changes.

+ /// A further example np.einsum('ij,jk', a, b) + /// describes traditional matrix multiplication and is equivalent to + /// np.matmul(a,b).

+ /// Repeated subscript labels in one + /// operand take the diagonal.

+ /// For example, np.einsum('ii', a) is equivalent + /// to np.trace(a).

+ /// + /// In implicit mode, the chosen subscripts are important + /// since the axes of the output are reordered alphabetically.

+ /// This + /// means that np.einsum('ij', a) doesn’t affect a 2D array, while + /// np.einsum('ji', a) takes its transpose.

+ /// Additionally, + /// np.einsum('ij,jk', a, b) returns a matrix multiplication, while, + /// np.einsum('ij,jh', a, b) returns the transpose of the + /// multiplication since subscript ‘h’ precedes subscript ‘i’. + /// + /// In explicit mode the output can be directly controlled by + /// specifying output subscript labels.

+ /// This requires the + /// identifier ‘->’ as well as the list of output subscript labels.

+ /// + /// This feature increases the flexibility of the function since + /// summing can be disabled or forced when required.

+ /// The call + /// np.einsum('i->', a) is like np.sum(a, axis=-1), + /// and np.einsum('ii->i', a) is like np.diag(a).

+ /// + /// The difference is that einsum does not allow broadcasting by default.

+ /// + /// Additionally np.einsum('ij,jh->ih', a, b) directly specifies the + /// order of the output subscript labels and therefore returns matrix + /// multiplication, unlike the example above in implicit mode.

+ /// + /// To enable and control broadcasting, use an ellipsis.

+ /// Default + /// NumPy-style broadcasting is done by adding an ellipsis + /// to the left of each term, like np.einsum('...ii->...i', a).

+ /// + /// To take the trace along the first and last axes, + /// you can do np.einsum('i...i', a), or to do a matrix-matrix + /// product with the left-most indices instead of rightmost, one can do + /// np.einsum('ij...,jk...->ik...', a, b).

+ /// + /// When there is only one operand, no axes are summed, and no output + /// parameter is provided, a view into the operand is returned instead + /// of a new array.

+ /// Thus, taking the diagonal as np.einsum('ii->i', a) + /// produces a view (changed in version 1.10.0).

+ /// + /// einsum also provides an alternative way to provide the subscripts + /// and operands as einsum(op0, sublist0, op1, sublist1, ..., [sublistout]).

+ /// + /// If the output shape is not provided in this format einsum will be + /// calculated in implicit mode, otherwise it will be performed explicitly.

+ /// + /// The examples below have corresponding einsum calls with the two + /// parameter methods.

+ /// + /// Views returned from einsum are now writeable whenever the input array + /// is writeable.

+ /// For example, np.einsum('ijk...->kji...', a) will now + /// have the same effect as np.swapaxes(a, 0, 2) + /// and np.einsum('ii->i', a) will return a writeable view of the diagonal + /// of a 2D array.

+ /// + /// Added the optimize argument which will optimize the contraction order + /// of an einsum expression.

+ /// For a contraction with three or more operands this + /// can greatly increase the computational efficiency at the cost of a larger + /// memory footprint during computation.

+ /// + /// Typically a ‘greedy’ algorithm is applied which empirical tests have shown + /// returns the optimal path in the majority of cases.

+ /// In some cases ‘optimal’ + /// will return the superlative path through a more expensive, exhaustive search.

+ /// + /// For iterative calculations it may be advisable to calculate the optimal path + /// once and reuse that path by supplying it as an argument.

+ /// An example is given + /// below.

+ /// + /// See numpy.einsum_path for more details. + /// + /// + /// Specifies the subscripts for summation as comma separated list of + /// subscript labels.

+ /// An implicit (classical Einstein summation) + /// calculation is performed unless the explicit indicator ‘->’ is + /// included as well as subscript labels of the precise output form. + /// + /// + /// These are the arrays for the operation. + /// + /// + /// If provided, the calculation is done into this array. + /// + /// + /// If provided, forces the calculation to use the data type specified.

+ /// + /// Note that you may have to also give a more liberal casting + /// parameter to allow the conversions.

+ /// Default is None. + /// + /// + /// Controls the memory layout of the output.

+ /// ‘C’ means it should + /// be C contiguous.

+ /// ‘F’ means it should be Fortran contiguous, + /// ‘A’ means it should be ‘F’ if the inputs are all ‘F’, ‘C’ otherwise.

+ /// + /// ‘K’ means it should be as close to the layout as the inputs as + /// is possible, including arbitrarily permuted axes.

+ /// + /// Default is ‘K’. + /// + /// + /// Controls what kind of data casting may occur.

+ /// Setting this to + /// ‘unsafe’ is not recommended, as it can adversely affect accumulations.

+ /// + /// Default is ‘safe’. + /// + /// + /// Controls if intermediate optimization should occur.

+ /// No optimization + /// will occur if False and True will default to the ‘greedy’ algorithm.

+ /// + /// Also accepts an explicit contraction list from the np.einsum_path + /// function.

+ /// See np.einsum_path for more details.

+ /// Defaults to False. + /// + /// + /// The calculation based on the Einstein summation convention. + /// + public static NDarray einsum(string subscripts, NDarray[] operands, NDarray @out = null, Dtype dtype = null, string order = null, string casting = "safe", object optimize = null) + { + //auto-generated code, do not change + var __self__ = self; + var pyargs = ToTuple(new object[] + { + subscripts, + }.Concat(operands.OfType()).ToArray()); + var kwargs = new PyDict(); + if (@out != null) kwargs["out"] = ToPython(@out); + if (dtype != null) kwargs["dtype"] = ToPython(dtype); + if (order != null) kwargs["order"] = ToPython(order); + if (casting != "safe") kwargs["casting"] = ToPython(casting); + if (optimize != null) kwargs["optimize"] = ToPython(optimize); + dynamic py = __self__.InvokeMethod("einsum", pyargs, kwargs); + return ToCsharp(py); + } + + /// + /// Evaluates the Einstein summation convention on the operands.

+ /// + /// Using the Einstein summation convention, many common multi-dimensional, + /// linear algebraic array operations can be represented in a simple fashion.

+ /// + /// In implicit mode einsum computes these values.

+ /// + /// In explicit mode, einsum provides further flexibility to compute + /// other array operations that might not be considered classical Einstein + /// summation operations, by disabling, or forcing summation over specified + /// subscript labels.

+ /// + /// See the notes and examples for clarification.

+ /// + /// Notes + /// + /// The Einstein summation convention can be used to compute + /// many multi-dimensional, linear algebraic array operations.

+ /// einsum + /// provides a succinct way of representing these.

+ /// + /// A non-exhaustive list of these operations, + /// which can be computed by einsum, is shown below along with examples: + /// + /// The subscripts string is a comma-separated list of subscript labels, + /// where each label refers to a dimension of the corresponding operand.

+ /// + /// Whenever a label is repeated it is summed, so np.einsum('i,i', a, b) + /// is equivalent to np.inner(a,b).

+ /// If a label + /// appears only once, it is not summed, so np.einsum('i', a) produces a + /// view of a with no changes.

+ /// A further example np.einsum('ij,jk', a, b) + /// describes traditional matrix multiplication and is equivalent to + /// np.matmul(a,b).

+ /// Repeated subscript labels in one + /// operand take the diagonal.

+ /// For example, np.einsum('ii', a) is equivalent + /// to np.trace(a).

+ /// + /// In implicit mode, the chosen subscripts are important + /// since the axes of the output are reordered alphabetically.

+ /// This + /// means that np.einsum('ij', a) doesn’t affect a 2D array, while + /// np.einsum('ji', a) takes its transpose.

+ /// Additionally, + /// np.einsum('ij,jk', a, b) returns a matrix multiplication, while, + /// np.einsum('ij,jh', a, b) returns the transpose of the + /// multiplication since subscript ‘h’ precedes subscript ‘i’. + /// + /// In explicit mode the output can be directly controlled by + /// specifying output subscript labels.

+ /// This requires the + /// identifier ‘->’ as well as the list of output subscript labels.

+ /// + /// This feature increases the flexibility of the function since + /// summing can be disabled or forced when required.

+ /// The call + /// np.einsum('i->', a) is like np.sum(a, axis=-1), + /// and np.einsum('ii->i', a) is like np.diag(a).

+ /// + /// The difference is that einsum does not allow broadcasting by default.

+ /// + /// Additionally np.einsum('ij,jh->ih', a, b) directly specifies the + /// order of the output subscript labels and therefore returns matrix + /// multiplication, unlike the example above in implicit mode.

+ /// + /// To enable and control broadcasting, use an ellipsis.

+ /// Default + /// NumPy-style broadcasting is done by adding an ellipsis + /// to the left of each term, like np.einsum('...ii->...i', a).

+ /// + /// To take the trace along the first and last axes, + /// you can do np.einsum('i...i', a), or to do a matrix-matrix + /// product with the left-most indices instead of rightmost, one can do + /// np.einsum('ij...,jk...->ik...', a, b).

+ /// + /// When there is only one operand, no axes are summed, and no output + /// parameter is provided, a view into the operand is returned instead + /// of a new array.

+ /// Thus, taking the diagonal as np.einsum('ii->i', a) + /// produces a view (changed in version 1.10.0).

+ /// + /// einsum also provides an alternative way to provide the subscripts + /// and operands as einsum(op0, sublist0, op1, sublist1, ..., [sublistout]).

+ /// + /// If the output shape is not provided in this format einsum will be + /// calculated in implicit mode, otherwise it will be performed explicitly.

+ /// + /// The examples below have corresponding einsum calls with the two + /// parameter methods.

+ /// + /// Views returned from einsum are now writeable whenever the input array + /// is writeable.

+ /// For example, np.einsum('ijk...->kji...', a) will now + /// have the same effect as np.swapaxes(a, 0, 2) + /// and np.einsum('ii->i', a) will return a writeable view of the diagonal + /// of a 2D array.

+ /// + /// Added the optimize argument which will optimize the contraction order + /// of an einsum expression.

+ /// For a contraction with three or more operands this + /// can greatly increase the computational efficiency at the cost of a larger + /// memory footprint during computation.

+ /// + /// Typically a ‘greedy’ algorithm is applied which empirical tests have shown + /// returns the optimal path in the majority of cases.

+ /// In some cases ‘optimal’ + /// will return the superlative path through a more expensive, exhaustive search.

+ /// + /// For iterative calculations it may be advisable to calculate the optimal path + /// once and reuse that path by supplying it as an argument.

+ /// An example is given + /// below.

+ /// + /// See numpy.einsum_path for more details. + /// + /// + /// Specifies the subscripts for summation as comma separated list of + /// subscript labels.

+ /// An implicit (classical Einstein summation) + /// calculation is performed unless the explicit indicator ‘->’ is + /// included as well as subscript labels of the precise output form. + /// + /// + /// These are the arrays for the operation. + /// + /// + /// If provided, the calculation is done into this array. + /// + /// + /// If provided, forces the calculation to use the data type specified.

+ /// + /// Note that you may have to also give a more liberal casting + /// parameter to allow the conversions.

+ /// Default is None. + /// + /// + /// Controls the memory layout of the output.

+ /// ‘C’ means it should + /// be C contiguous.

+ /// ‘F’ means it should be Fortran contiguous, + /// ‘A’ means it should be ‘F’ if the inputs are all ‘F’, ‘C’ otherwise.

+ /// + /// ‘K’ means it should be as close to the layout as the inputs as + /// is possible, including arbitrarily permuted axes.

+ /// + /// Default is ‘K’. + /// + /// + /// Controls what kind of data casting may occur.

+ /// Setting this to + /// ‘unsafe’ is not recommended, as it can adversely affect accumulations.

+ /// + /// Default is ‘safe’. + /// + /// + /// Controls if intermediate optimization should occur.

+ /// No optimization + /// will occur if False and True will default to the ‘greedy’ algorithm.

+ /// + /// Also accepts an explicit contraction list from the np.einsum_path + /// function.

+ /// See np.einsum_path for more details.

+ /// Defaults to False. + /// + /// + /// The calculation based on the Einstein summation convention. + /// + public static NDarray einsum(string subscripts, params NDarray[] operands) + { + //auto-generated code, do not change + var __self__ = self; + var pyargs = ToTuple(new object[] + { + subscripts, + }.Concat(operands.OfType()).ToArray()); + var kwargs = new PyDict(); + dynamic py = __self__.InvokeMethod("einsum", pyargs, kwargs); + return ToCsharp(py); + } + + } +} diff --git a/src/Numpy/Manual/np.insert.cs b/src/Numpy/Manual/np.insert.cs new file mode 100644 index 0000000..18f6a10 --- /dev/null +++ b/src/Numpy/Manual/np.insert.cs @@ -0,0 +1,243 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using Numpy; +using Numpy.Models; +using Python.Runtime; + +namespace Numpy +{ + /// + /// Manual type conversions + /// + public static partial class np + { + + /// + /// Insert values along the given axis before the given indices.

+ /// + /// Notes + /// + /// Note that for higher dimensional inserts obj=0 behaves very different + /// from obj=[0] just like arr[:,0,:] = values is different from + /// arr[:,[0],:] = values. + /// + /// + /// Input array. + /// + /// + /// Object that defines the index or indices before which values is + /// inserted.

+ /// + /// Support for multiple insertions when obj is a single scalar or a + /// sequence with one element (similar to calling insert multiple + /// times). + /// + /// + /// Values to insert into arr.

+ /// If the type of values is different + /// from that of arr, values is converted to the type of arr.

+ /// + /// values should be shaped so that arr[...,obj,...] = values + /// is legal. + /// + /// + /// Axis along which to insert values.

+ /// If axis is None then arr + /// is flattened first. + /// + /// + /// A copy of arr with values inserted.

+ /// Note that insert + /// does not occur in-place: a new array is returned.

+ /// If + /// axis is None, out is a flattened array. + /// + public static NDarray insert(NDarray arr, int obj, NDarray values = null, int? axis = null) + { + //auto-generated code, do not change + var __self__ = self; + var pyargs = ToTuple(new object[] + { + arr, + ToPython(obj), + }); + var kwargs = new PyDict(); + if (values != null) kwargs["values"] = ToPython(values); + if (axis != null) kwargs["axis"] = ToPython(axis); + dynamic py = __self__.InvokeMethod("insert", pyargs, kwargs); + return ToCsharp(py); + } + + /// + /// Insert values along the given axis before the given indices.

+ /// + /// Notes + /// + /// Note that for higher dimensional inserts obj=0 behaves very different + /// from obj=[0] just like arr[:,0,:] = values is different from + /// arr[:,[0],:] = values. + /// + /// + /// Input array. + /// + /// + /// Object that defines the index or indices before which values is + /// inserted.

+ /// + /// Support for multiple insertions when obj is a single scalar or a + /// sequence with one element (similar to calling insert multiple + /// times). + /// + /// + /// Values to insert into arr.

+ /// If the type of values is different + /// from that of arr, values is converted to the type of arr.

+ /// + /// values should be shaped so that arr[...,obj,...] = values + /// is legal. + /// + /// + /// Axis along which to insert values.

+ /// If axis is None then arr + /// is flattened first. + /// + /// + /// A copy of arr with values inserted.

+ /// Note that insert + /// does not occur in-place: a new array is returned.

+ /// If + /// axis is None, out is a flattened array. + /// + public static NDarray insert(NDarray arr, NDarray obj, NDarray values = null, int? axis = null) + { + //auto-generated code, do not change + var __self__ = self; + var pyargs = ToTuple(new object[] + { + arr, + obj, + }); + var kwargs = new PyDict(); + if (values != null) kwargs["values"] = ToPython(values); + if (axis != null) kwargs["axis"] = ToPython(axis); + dynamic py = __self__.InvokeMethod("insert", pyargs, kwargs); + return ToCsharp(py); + } + + /// + /// Insert values along the given axis before the given indices.

+ /// + /// Notes + /// + /// Note that for higher dimensional inserts obj=0 behaves very different + /// from obj=[0] just like arr[:,0,:] = values is different from + /// arr[:,[0],:] = values. + /// + /// + /// Input array. + /// + /// + /// Object that defines the index or indices before which values is + /// inserted.

+ /// + /// Support for multiple insertions when obj is a single scalar or a + /// sequence with one element (similar to calling insert multiple + /// times). + /// + /// + /// Values to insert into arr.

+ /// If the type of values is different + /// from that of arr, values is converted to the type of arr.

+ /// + /// values should be shaped so that arr[...,obj,...] = values + /// is legal. + /// + /// + /// Axis along which to insert values.

+ /// If axis is None then arr + /// is flattened first. + /// + /// + /// A copy of arr with values inserted.

+ /// Note that insert + /// does not occur in-place: a new array is returned.

+ /// If + /// axis is None, out is a flattened array. + /// + public static NDarray insert(NDarray arr, Slice obj, NDarray values = null, int? axis = null) + { + //auto-generated code, do not change + var __self__ = self; + var pyargs = ToTuple(new object[] + { + arr, + obj.ToPython(), + }); + var kwargs = new PyDict(); + if (values != null) kwargs["values"] = ToPython(values); + if (axis != null) kwargs["axis"] = ToPython(axis); + dynamic py = __self__.InvokeMethod("insert", pyargs, kwargs); + return ToCsharp(py); + } + + /// + /// Insert values along the given axis before the given indices.

+ /// + /// Notes + /// + /// Note that for higher dimensional inserts obj=0 behaves very different + /// from obj=[0] just like arr[:,0,:] = values is different from + /// arr[:,[0],:] = values. + /// + /// + /// Input array. + /// + /// + /// Object that defines the index or indices before which values is + /// inserted.

+ /// + /// Support for multiple insertions when obj is a single scalar or a + /// sequence with one element (similar to calling insert multiple + /// times). + /// + /// + /// Values to insert into arr.

+ /// If the type of values is different + /// from that of arr, values is converted to the type of arr.

+ /// + /// values should be shaped so that arr[...,obj,...] = values + /// is legal. + /// + /// + /// Axis along which to insert values.

+ /// If axis is None then arr + /// is flattened first. + /// + /// + /// A copy of arr with values inserted.

+ /// Note that insert + /// does not occur in-place: a new array is returned.

+ /// If + /// axis is None, out is a flattened array. + /// + public static NDarray insert(NDarray arr, int obj, T values, int? axis = null) where T : struct + { + //auto-generated code, do not change + var __self__ = self; + var pyargs = ToTuple(new object[] + { + arr, + ToPython(obj), + }); + var kwargs = new PyDict(); + kwargs["values"] = ToPython(values); + if (axis != null) kwargs["axis"] = ToPython(axis); + dynamic py = __self__.InvokeMethod("insert", pyargs, kwargs); + return ToCsharp(py); + } + + } +} diff --git a/src/Numpy/Manual/np.linalg.norm.cs b/src/Numpy/Manual/np.linalg.norm.cs index 64f3dce..98b0580 100644 --- a/src/Numpy/Manual/np.linalg.norm.cs +++ b/src/Numpy/Manual/np.linalg.norm.cs @@ -114,6 +114,99 @@ public static float norm(NDarray x, Constants ord) dynamic py = linalg.InvokeMethod("norm", pyargs, kwargs); return ToCsharp(py); } + + /// + /// Compute the qr factorization of a matrix.

+ /// + /// Factor the matrix a as qr, where q is orthonormal and r is + /// upper-triangular.

+ /// + /// Notes + /// + /// This is an interface to the LAPACK routines dgeqrf, zgeqrf, + /// dorgqr, and zungqr.

+ /// + /// For more information on the qr factorization, see for example: + /// https://en.wikipedia.org/wiki/QR_factorization + /// + /// Subclasses of ndarray are preserved except for the ‘raw’ mode.

+ /// So if + /// a is of type matrix, all the return values will be matrices too.

+ /// + /// New ‘reduced’, ‘complete’, and ‘raw’ options for mode were added in + /// NumPy 1.8.0 and the old option ‘full’ was made an alias of ‘reduced’. In + /// addition the options ‘full’ and ‘economic’ were deprecated.

+ /// Because + /// ‘full’ was the previous default and ‘reduced’ is the new default, + /// backward compatibility can be maintained by letting mode default.

+ /// + /// The ‘raw’ option was added so that LAPACK routines that can multiply + /// arrays by q using the Householder reflectors can be used.

+ /// Note that in + /// this case the returned arrays are of type np.double or np.cdouble and + /// the h array is transposed to be FORTRAN compatible.

+ /// No routines using + /// the ‘raw’ return are currently exposed by numpy, but some are available + /// in lapack_lite and just await the necessary work. + /// + /// + /// Matrix to be factored. + /// + /// + /// If K = min(M, N), then + /// + /// The options ‘reduced’, ‘complete, and ‘raw’ are new in numpy 1.8, + /// see the notes for more information.

+ /// The default is ‘reduced’, and to + /// maintain backward compatibility with earlier versions of numpy both + /// it and the old default ‘full’ can be omitted.

+ /// Note that array h + /// returned in ‘raw’ mode is transposed for calling Fortran.

+ /// The + /// ‘economic’ mode is deprecated.

+ /// The modes ‘full’ and ‘economic’ may + /// be passed using only the first letter for backwards compatibility, + /// but all others must be spelled out.

+ /// See the Notes for more + /// explanation. + /// + /// + /// A tuple of: + /// q + /// A matrix with orthonormal columns. When mode = ‘complete’ the + /// result is an orthogonal/unitary matrix depending on whether or not + /// a is real/complex. The determinant may be either +/- 1 in that + /// case. + /// r + /// The upper-triangular matrix. + /// (h, tau) + /// The array h contains the Householder reflectors that generate q + /// along with r. The tau array contains scaling factors for the + /// reflectors. In the deprecated ‘economic’ mode only h is returned. + /// + public static (NDarray, NDarray, NDarray) qr(NDarray a, string mode = "reduced") + { + //auto-generated code, do not change + var linalg = self.GetAttr("linalg"); + var __self__ = linalg; + var pyargs = ToTuple(new object[] + { + a, + }); + var kwargs = new PyDict(); + if (mode != "reduced") kwargs["mode"] = ToPython(mode); + dynamic py = __self__.InvokeMethod("qr", pyargs, kwargs); + if (PythonObject.IsNDarray(py)) + return (ToCsharp(py), null, null); + if (PythonObject.IsTuple(py)) + { + if (ToCsharp(py.__len__()) == 2) + return (ToCsharp(py[0]), ToCsharp(py[1]), null); + return (ToCsharp(py[0]), ToCsharp(py[1]), ToCsharp(py[2])); + } + throw new NotSupportedException("Unexpected return type: " + + ToCsharp(py.__class__.__name__)); + } } } } diff --git a/src/Numpy/Manual/np.math.cs b/src/Numpy/Manual/np.math.cs new file mode 100644 index 0000000..9c75d80 --- /dev/null +++ b/src/Numpy/Manual/np.math.cs @@ -0,0 +1,262 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using System.Runtime.InteropServices; +using System.Text; +using Numpy; +using Numpy.Models; +using Python.Runtime; + +namespace Numpy +{ + /// + /// Manual type conversions + /// + public static partial class np + { + + /// + /// Return the gradient of an N-dimensional array.

+ /// + /// The gradient is computed using second order accurate central differences + /// in the interior points and either first or second order accurate one-sides + /// (forward or backwards) differences at the boundaries.

+ /// + /// The returned gradient hence has the same shape as the input array.

+ /// + /// Notes + /// + /// Assuming that (i.e., has at least 3 continuous + /// derivatives) and let be a non-homogeneous stepsize, we + /// minimize the “consistency error” between the true gradient + /// and its estimate from a linear combination of the neighboring grid-points: + /// + /// By substituting and + /// with their Taylor series expansion, this translates into solving + /// the following the linear system: + /// + /// The resulting approximation of is the following: + /// + /// It is worth noting that if + /// (i.e., data are evenly spaced) + /// we find the standard second order approximation: + /// + /// With a similar procedure the forward/backward approximations used for + /// boundaries can be derived.

+ /// + /// References + /// + /// + /// An N-dimensional array containing samples of a scalar function. + /// + /// + /// Spacing between f values.

+ /// Default unitary spacing for all dimensions.

+ /// + /// Spacing can be specified using: + /// + /// If axis is given, the number of varargs must equal the number of axes.

+ /// + /// Default: 1. + /// + /// + /// Gradient is calculated using N-th order accurate differences + /// at the boundaries.

+ /// Default: 1. + /// + /// + /// Gradient is calculated only along the given axis or axes + /// The default (axis = None) is to calculate the gradient for all the axes + /// of the input array.

+ /// axis may be negative, in which case it counts from + /// the last to the first axis. + /// + /// + /// A set of ndarrays (or a single ndarray if there is only one dimension) + /// corresponding to the derivatives of f with respect to each dimension.

+ /// + /// Each derivative has the same shape as f. + /// + public static NDarray gradient(NDarray f, int? edge_order = null, Axis axis = null) + { + //auto-generated code, do not change + var __self__ = self; + + var pyargs = new PyObject[] { f.PyObject }; + var kwargs = new PyDict(); + if (edge_order != null) kwargs["edge_order"] = ToPython(edge_order); + if (axis != null) kwargs["axis"] = ToPython(axis); + dynamic py = __self__.InvokeMethod("gradient", pyargs, kwargs); + return ToCsharp(py); + } + + /// + /// Return the gradient of an N-dimensional array.

+ /// + /// The gradient is computed using second order accurate central differences + /// in the interior points and either first or second order accurate one-sides + /// (forward or backwards) differences at the boundaries.

+ /// + /// The returned gradient hence has the same shape as the input array.

+ /// + /// Notes + /// + /// Assuming that (i.e., has at least 3 continuous + /// derivatives) and let be a non-homogeneous stepsize, we + /// minimize the “consistency error” between the true gradient + /// and its estimate from a linear combination of the neighboring grid-points: + /// + /// By substituting and + /// with their Taylor series expansion, this translates into solving + /// the following the linear system: + /// + /// The resulting approximation of is the following: + /// + /// It is worth noting that if + /// (i.e., data are evenly spaced) + /// we find the standard second order approximation: + /// + /// With a similar procedure the forward/backward approximations used for + /// boundaries can be derived.

+ /// + /// References + /// + /// + /// An N-dimensional array containing samples of a scalar function. + /// + /// + /// Spacing between f values.

+ /// Default unitary spacing for all dimensions.

+ /// + /// Spacing can be specified using: + /// + /// If axis is given, the number of varargs must equal the number of axes.

+ /// + /// Default: 1. + /// + /// + /// Gradient is calculated using N-th order accurate differences + /// at the boundaries.

+ /// Default: 1. + /// + /// + /// Gradient is calculated only along the given axis or axes + /// The default (axis = None) is to calculate the gradient for all the axes + /// of the input array.

+ /// axis may be negative, in which case it counts from + /// the last to the first axis. + /// + /// + /// A set of ndarrays (or a single ndarray if there is only one dimension) + /// corresponding to the derivatives of f with respect to each dimension.

+ /// + /// Each derivative has the same shape as f. + /// + public static NDarray gradient(NDarray f, List varargs, int? edge_order = null, Axis axis = null) + { + //auto-generated code, do not change + var __self__ = self; + + var pyargs = new PyObject[] { f.PyObject }.Concat(varargs.Select(x => new PyFloat(x))).ToArray(); + var kwargs = new PyDict(); + if (edge_order != null) kwargs["edge_order"] = ToPython(edge_order); + if (axis != null) kwargs["axis"] = ToPython(axis); + dynamic py = __self__.InvokeMethod("gradient", pyargs, kwargs); + return ToCsharp(py); + } + + /// + /// One-dimensional linear interpolation.

+ /// + /// Returns the one-dimensional piecewise linear interpolant to a function + /// with given discrete data points (xp, fp), evaluated at x.

+ /// + /// Notes + /// + /// Does not check that the x-coordinate sequence xp is increasing.

+ /// + /// If xp is not increasing, the results are nonsense.

+ /// + /// A simple check for increasing is: + /// + /// + /// The x-coordinates at which to evaluate the interpolated values. + /// + /// + /// The x-coordinates of the data points, must be increasing if argument + /// period is not specified.

+ /// Otherwise, xp is internally sorted after + /// normalizing the periodic boundaries with xp = xp % period. + /// + /// + /// The y-coordinates of the data points, same length as xp. + /// + /// + /// Value to return for x < xp[0], default is fp[0]. + /// + /// + /// Value to return for x > xp[-1], default is fp[-1]. + /// + /// + /// A period for the x-coordinates.

+ /// This parameter allows the proper + /// interpolation of angular x-coordinates.

+ /// Parameters left and right + /// are ignored if period is specified. + /// + /// + /// The interpolated values, same shape as x. + /// + public static NDarray interp(this NDarray x, IReadOnlyCollection xp, IReadOnlyCollection fp, float? left = null, float? right = null, float? period = null) + { + var __self__ = self; + var pyargs = ToTuple(new object[] + { + x, + xp, + fp, + }); + var kwargs = new PyDict(); + if (left != null) kwargs["left"] = ToPython(left); + if (right != null) kwargs["right"] = ToPython(right); + if (period != null) kwargs["period"] = ToPython(period); + dynamic py = __self__.InvokeMethod("interp", pyargs, kwargs); + return ToCsharp(py); + } + + public static float interp(float x, IReadOnlyCollection xp, IReadOnlyCollection fp, float? left = null, float? right = null, float? period = null) + { + var __self__ = self; + var pyargs = ToTuple(new object[] + { + x, + xp, + fp, + }); + var kwargs = new PyDict(); + if (left != null) kwargs["left"] = ToPython(left); + if (right != null) kwargs["right"] = ToPython(right); + if (period != null) kwargs["period"] = ToPython(period); + dynamic py = __self__.InvokeMethod("interp", pyargs, kwargs); + return ToCsharp(py); + } + + public static NDarray interp(this NDarray x, IReadOnlyCollection xp, Complex[] fp, Complex? left = null, Complex? right = null, float? period = null) + { + var __self__ = self; + var pyargs = ToTuple(new object[] + { + x, + xp, + np.array(fp), + }); + var kwargs = new PyDict(); + if (left != null) kwargs["left"] = ToPython(left); + if (right != null) kwargs["right"] = ToPython(right); + if (period != null) kwargs["period"] = ToPython(period); + dynamic py = __self__.InvokeMethod("interp", pyargs, kwargs); + return ToCsharp(py); + } + } +} diff --git a/src/Numpy/Models/NDarray.Operators.cs b/src/Numpy/Models/NDarray.Operators.cs index 9c12033..b54d4e7 100644 --- a/src/Numpy/Models/NDarray.Operators.cs +++ b/src/Numpy/Models/NDarray.Operators.cs @@ -199,7 +199,7 @@ public static NDarray nonzero(NDarray a) public static NDarray operator /(ValueType obj, NDarray a) { if (operator_module == null) - operator_module = PythonEngine.ImportModule("operator"); + operator_module = Py.Import("operator"); return new NDarray(operator_module.InvokeMethod("__truediv__", obj.ToPython(), a.self)); } @@ -289,6 +289,14 @@ public NDarray pow(ValueType obj) return new NDarray(a.self.InvokeMethod("__and__", obj.ToPython())); } + /// + /// Return self&value. + /// + public static NDarray operator &(NDarray a, NDarray b) + { + return new NDarray(a.self.InvokeMethod("__and__", b.self)); + } + /// /// Return self|value. /// @@ -297,6 +305,14 @@ public NDarray pow(ValueType obj) return new NDarray(a.self.InvokeMethod("__or__", obj.ToPython())); } + /// + /// Return self|value. + /// + public static NDarray operator |(NDarray a, NDarray b) + { + return new NDarray(a.self.InvokeMethod("__or__", b.self)); + } + /// /// Return self^value. /// @@ -305,6 +321,14 @@ public NDarray pow(ValueType obj) return new NDarray(a.self.InvokeMethod("__xor__", obj.ToPython())); } + /// + /// Return self^value. + /// + public static NDarray operator ^(NDarray a, NDarray b) + { + return new NDarray(a.self.InvokeMethod("__xor__", b.self)); + } + //------------------------------ // Arithmetic, in-place: //------------------------------ diff --git a/src/Numpy/Models/NDarray.cs b/src/Numpy/Models/NDarray.cs index d9624f6..e0fe058 100644 --- a/src/Numpy/Models/NDarray.cs +++ b/src/Numpy/Models/NDarray.cs @@ -671,5 +671,12 @@ public T[] GetData() } } + public T item() + { + if (typeof(T) == typeof(Complex)) + return (T)(object)new Complex(real.asscalar(), imag.asscalar()); + return self.InvokeMethod("item").As(); + } + } } diff --git a/src/Numpy/Models/NDarray.gen.cs b/src/Numpy/Models/NDarray.gen.cs index e0e9f06..2bd1fa4 100644 --- a/src/Numpy/Models/NDarray.gen.cs +++ b/src/Numpy/Models/NDarray.gen.cs @@ -456,12694 +456,5 @@ public void __setstate__(int version, Shape shape, Dtype dtype, bool isFortran, dynamic py = __self__.InvokeMethod("__setstate__", pyargs, kwargs); } - /// - /// Gives a new shape to an array without changing its data.

- /// - /// Notes - /// - /// It is not always possible to change the shape of an array without - /// copying the data.

- /// If you want an error to be raised when the data is copied, - /// you should assign the new shape to the shape attribute of the array: - /// - /// The order keyword gives the index ordering both for fetching the values - /// from a, and then placing the values into the output array.

- /// - /// For example, let’s say you have an array: - /// - /// You can think of reshaping as first raveling the array (using the given - /// index order), then inserting the elements from the raveled array into the - /// new array using the same kind of index ordering as was used for the - /// raveling. - /// - /// - /// The new shape should be compatible with the original shape.

- /// If - /// an integer, then the result will be a 1-D array of that length.

- /// - /// One shape dimension can be -1. In this case, the value is - /// inferred from the length of the array and remaining dimensions. - /// - /// - /// Read the elements of a using this index order, and place the - /// elements into the reshaped array using this index order.

- /// ‘C’ - /// means to read / write the elements using C-like index order, - /// with the last axis index changing fastest, back to the first - /// axis index changing slowest.

- /// ‘F’ means to read / write the - /// elements using Fortran-like index order, with the first index - /// changing fastest, and the last index changing slowest.

- /// Note that - /// the ‘C’ and ‘F’ options take no account of the memory layout of - /// the underlying array, and only refer to the order of indexing.

- /// - /// ‘A’ means to read / write the elements in Fortran-like index - /// order if a is Fortran contiguous in memory, C-like order - /// otherwise. - /// - /// - /// This will be a new view object if possible; otherwise, it will - /// be a copy.

- /// Note there is no guarantee of the memory layout (C- or - /// Fortran- contiguous) of the returned array. - /// - public NDarray reshape(Shape newshape, string order = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - newshape, - }); - var kwargs=new PyDict(); - if (order!=null) kwargs["order"]=ToPython(order); - dynamic py = __self__.InvokeMethod("reshape", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return a contiguous flattened array.

- /// - /// A 1-D array, containing the elements of the input, is returned.

- /// A copy is - /// made only if needed.

- /// - /// As of NumPy 1.10, the returned array will have the same type as the input - /// array.

- /// (for example, a masked array will be returned for a masked array - /// input) - /// - /// Notes - /// - /// In row-major, C-style order, in two dimensions, the row index - /// varies the slowest, and the column index the quickest.

- /// This can - /// be generalized to multiple dimensions, where row-major order - /// implies that the index along the first axis varies slowest, and - /// the index along the last quickest.

- /// The opposite holds for - /// column-major, Fortran-style index ordering.

- /// - /// When a view is desired in as many cases as possible, arr.reshape(-1) - /// may be preferable. - /// - /// - /// The elements of a are read using this index order.

- /// ‘C’ means - /// to index the elements in row-major, C-style order, - /// with the last axis index changing fastest, back to the first - /// axis index changing slowest.

- /// ‘F’ means to index the elements - /// in column-major, Fortran-style order, with the - /// first index changing fastest, and the last index changing - /// slowest.

- /// Note that the ‘C’ and ‘F’ options take no account of - /// the memory layout of the underlying array, and only refer to - /// the order of axis indexing.

- /// ‘A’ means to read the elements in - /// Fortran-like index order if a is Fortran contiguous in - /// memory, C-like order otherwise.

- /// ‘K’ means to read the - /// elements in the order they occur in memory, except for - /// reversing the data when strides are negative.

- /// By default, ‘C’ - /// index order is used. - /// - /// - /// y is an array of the same subtype as a, with shape (a.size,).

- /// - /// Note that matrices are special cased for backward compatibility, if a - /// is a matrix, then y is a 1-D ndarray. - /// - public NDarray ravel(string order = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (order!=null) kwargs["order"]=ToPython(order); - dynamic py = __self__.InvokeMethod("ravel", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Move axes of an array to new positions.

- /// - /// Other axes remain in their original order. - /// - /// - /// Original positions of the axes to move.

- /// These must be unique. - /// - /// - /// Destination positions for each of the original axes.

- /// These must also be - /// unique. - /// - /// - /// Array with moved axes.

- /// This array is a view of the input array. - /// - public NDarray moveaxis(int[] source, int[] destination) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - source, - destination, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("moveaxis", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Roll the specified axis backwards, until it lies in a given position.

- /// - /// This function continues to be supported for backward compatibility, but you - /// should prefer moveaxis.

- /// The moveaxis function was added in NumPy - /// 1.11. - /// - /// - /// The axis to roll backwards.

- /// The positions of the other axes do not - /// change relative to one another. - /// - /// - /// The axis is rolled until it lies before this position.

- /// The default, - /// 0, results in a “complete” roll. - /// - /// - /// For NumPy >= 1.10.0 a view of a is always returned.

- /// For earlier - /// NumPy versions a view of a is returned only if the order of the - /// axes is changed, otherwise the input array is returned. - /// - public NDarray rollaxis(int axis, int? start = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - axis, - }); - var kwargs=new PyDict(); - if (start!=0) kwargs["start"]=ToPython(start); - dynamic py = __self__.InvokeMethod("rollaxis", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Interchange two axes of an array. - /// - /// - /// First axis. - /// - /// - /// Second axis. - /// - /// - /// For NumPy >= 1.10.0, if a is an ndarray, then a view of a is - /// returned; otherwise a new array is created.

- /// For earlier NumPy - /// versions a view of a is returned only if the order of the - /// axes is changed, otherwise the input array is returned. - /// - public NDarray swapaxes(int axis1, int axis2) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - axis1, - axis2, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("swapaxes", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Produce an object that mimics broadcasting. - /// - /// - /// Input parameters. - /// - /// - /// Broadcast the input parameters against one another, and - /// return an object that encapsulates the result.

- /// - /// Amongst others, it has shape and nd properties, and - /// may be used as an iterator. - /// - public NDarray broadcast(NDarray in1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - in1, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("broadcast", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Broadcast an array to a new shape.

- /// - /// Notes - /// - /// - /// The shape of the desired array. - /// - /// - /// If True, then sub-classes will be passed-through, otherwise - /// the returned array will be forced to be a base-class array (default). - /// - /// - /// A readonly view on the original array with the given shape.

- /// It is - /// typically not contiguous.

- /// Furthermore, more than one element of a - /// broadcasted array may refer to a single memory location. - /// - public NDarray broadcast_to(Shape shape, bool? subok = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - shape, - }); - var kwargs=new PyDict(); - if (subok!=false) kwargs["subok"]=ToPython(subok); - dynamic py = __self__.InvokeMethod("broadcast_to", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Expand the shape of an array.

- /// - /// Insert a new axis that will appear at the axis position in the expanded - /// array shape. - /// - /// - /// Position in the expanded axes where the new axis is placed. - /// - /// - /// Output array.

- /// The number of dimensions is one greater than that of - /// the input array. - /// - public NDarray expand_dims(int axis) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - axis, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("expand_dims", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Remove single-dimensional entries from the shape of an array. - /// - /// - /// Selects a subset of the single-dimensional entries in the - /// shape.

- /// If an axis is selected with shape entry greater than - /// one, an error is raised. - /// - /// - /// The input array, but with all or a subset of the - /// dimensions of length 1 removed.

- /// This is always a itself - /// or a view into a. - /// - public NDarray squeeze(Axis axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("squeeze", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return an array converted to a float type. - /// - /// - /// Float type code to coerce input array a.

- /// If dtype is one of the - /// ‘int’ dtypes, it is replaced with float64. - /// - /// - /// The input a as a float ndarray. - /// - public NDarray asfarray(Dtype dtype = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - dynamic py = __self__.InvokeMethod("asfarray", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return an array (ndim >= 1) laid out in Fortran order in memory. - /// - /// - /// By default, the data-type is inferred from the input data. - /// - /// - /// The input a in Fortran, or column-major, order. - /// - public NDarray asfortranarray(Dtype dtype = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - dynamic py = __self__.InvokeMethod("asfortranarray", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Convert the input to an array, checking for NaNs or Infs. - /// - /// - /// By default, the data-type is inferred from the input data. - /// - /// - /// Whether to use row-major (C-style) or - /// column-major (Fortran-style) memory representation.

- /// - /// Defaults to ‘C’. - /// - /// - /// Array interpretation of a.

- /// No copy is performed if the input - /// is already an ndarray.

- /// If a is a subclass of ndarray, a base - /// class ndarray is returned. - /// - public NDarray asarray_chkfinite(Dtype dtype = null, string order = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (order!=null) kwargs["order"]=ToPython(order); - dynamic py = __self__.InvokeMethod("asarray_chkfinite", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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).

- /// - /// Notes - /// - /// The returned array will be guaranteed to have the listed requirements - /// by making a copy if needed. - /// - /// - /// 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. - /// - /// - /// The requirements list can be any of the following - /// - public NDarray require(Dtype dtype, string[] requirements = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - dtype, - }); - var kwargs=new PyDict(); - if (requirements!=null) kwargs["requirements"]=ToPython(requirements); - dynamic py = __self__.InvokeMethod("require", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Split an array into multiple sub-arrays. - /// - /// - /// If indices_or_sections is an integer, N, the array will be divided - /// into N equal arrays along axis.

- /// If such a split is not possible, - /// an error is raised.

- /// - /// If indices_or_sections is a 1-D array of sorted integers, the entries - /// indicate where along axis the array is split.

- /// For example, - /// [2, 3] would, for axis=0, result in - /// - /// If an index exceeds the dimension of the array along axis, - /// an empty sub-array is returned correspondingly. - /// - /// - /// The axis along which to split, default is 0. - /// - /// - /// A list of sub-arrays. - /// - public NDarray[] split(int[] indices_or_sections, int? axis = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - indices_or_sections, - }); - var kwargs=new PyDict(); - if (axis!=0) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("split", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Construct an array by repeating A the number of times given by reps.

- /// - /// If reps has length d, the result will have dimension of - /// max(d, A.ndim).

- /// - /// If A.ndim < d, A is promoted to be d-dimensional by prepending new - /// axes.

- /// So a shape (3,) array is promoted to (1, 3) for 2-D replication, - /// or shape (1, 1, 3) for 3-D replication.

- /// If this is not the desired - /// behavior, promote A to d-dimensions manually before calling this - /// function.

- /// - /// If A.ndim > d, reps is promoted to A.ndim by pre-pending 1’s to it.

- /// - /// Thus for an A of shape (2, 3, 4, 5), a reps of (2, 2) is treated as - /// (1, 1, 2, 2).

- /// - /// Note : Although tile may be used for broadcasting, it is strongly - /// recommended to use numpy’s broadcasting operations and functions. - /// - /// - /// The number of repetitions of A along each axis. - /// - /// - /// The tiled output array. - /// - public NDarray tile(NDarray reps) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - reps, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("tile", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Repeat elements of an array. - /// - /// - /// The number of repetitions for each element.

- /// repeats is broadcasted - /// to fit the shape of the given axis. - /// - /// - /// The axis along which to repeat values.

- /// By default, use the - /// flattened input array, and return a flat output array. - /// - /// - /// Output array which has the same shape as a, except along - /// the given axis. - /// - public NDarray repeat(int[] repeats, int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - repeats, - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("repeat", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return a new array with sub-arrays along an axis deleted.

- /// For a one - /// dimensional array, this returns those entries not returned by - /// arr[obj].

- /// - /// Notes - /// - /// Often it is preferable to use a boolean mask.

- /// For example: - /// - /// Is equivalent to np.delete(arr, [0,2,4], axis=0), but allows further - /// use of mask. - /// - /// - /// Indicate which sub-arrays to remove. - /// - /// - /// The axis along which to delete the subarray defined by obj.

- /// - /// If axis is None, obj is applied to the flattened array. - /// - /// - /// A copy of arr with the elements specified by obj removed.

- /// Note - /// that delete does not occur in-place.

- /// If axis is None, out is - /// a flattened array. - /// - public NDarray delete(Slice obj, int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - obj, - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("delete", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Insert values along the given axis before the given indices.

- /// - /// Notes - /// - /// Note that for higher dimensional inserts obj=0 behaves very different - /// from obj=[0] just like arr[:,0,:] = values is different from - /// arr[:,[0],:] = values. - /// - /// - /// Object that defines the index or indices before which values is - /// inserted.

- /// - /// Support for multiple insertions when obj is a single scalar or a - /// sequence with one element (similar to calling insert multiple - /// times). - /// - /// - /// Values to insert into arr.

- /// If the type of values is different - /// from that of arr, values is converted to the type of arr.

- /// - /// values should be shaped so that arr[...,obj,...] = values - /// is legal. - /// - /// - /// Axis along which to insert values.

- /// If axis is None then arr - /// is flattened first. - /// - /// - /// A copy of arr with values inserted.

- /// Note that insert - /// does not occur in-place: a new array is returned.

- /// If - /// axis is None, out is a flattened array. - /// - public NDarray insert(int obj = 0, NDarray values = null, int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (obj!=0) kwargs["obj"]=ToPython(obj); - if (values!=null) kwargs["values"]=ToPython(values); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("insert", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Append values to the end of an array. - /// - /// - /// These values are appended to a copy of arr.

- /// It must be of the - /// correct shape (the same shape as arr, excluding axis).

- /// If - /// axis is not specified, values can be any shape and will be - /// flattened before use. - /// - /// - /// The axis along which values are appended.

- /// If axis is not - /// given, both arr and values are flattened before use. - /// - /// - /// A copy of arr with values appended to axis.

- /// Note that - /// append does not occur in-place: a new array is allocated and - /// filled.

- /// If axis is None, out is a flattened array. - /// - public NDarray append(NDarray values, int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - values, - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("append", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Trim the leading and/or trailing zeros from a 1-D array or sequence. - /// - /// - /// A string with ‘f’ representing trim from front and ‘b’ to trim from - /// back.

- /// Default is ‘fb’, trim zeros from both front and back of the - /// array. - /// - /// - /// The result of trimming the input.

- /// The input data type is preserved. - /// - public NDarray trim_zeros(string trim = "fb") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (trim!="fb") kwargs["trim"]=ToPython(trim); - dynamic py = __self__.InvokeMethod("trim_zeros", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Find the unique elements of an array.

- /// - /// Returns the sorted unique elements of an array.

- /// There are three optional - /// outputs in addition to the unique elements: - /// - /// Notes - /// - /// When an axis is specified the subarrays indexed by the axis are sorted.

- /// - /// This is done by making the specified axis the first dimension of the array - /// and then flattening the subarrays in C order.

- /// The flattened subarrays are - /// then viewed as a structured type with each element given a label, with the - /// effect that we end up with a 1-D array of structured types that can be - /// treated in the same way as any other 1-D array.

- /// The result is that the - /// flattened subarrays are sorted in lexicographic order starting with the - /// first element. - /// - /// - /// The axis to operate on.

- /// If None, ar will be flattened.

- /// If an integer, - /// the subarrays indexed by the given axis will be flattened and treated - /// as the elements of a 1-D array with the dimension of the given axis, - /// see the notes for more details.

- /// Object arrays or structured arrays - /// that contain objects are not supported if the axis kwarg is used.

- /// The - /// default is None. - /// - /// - /// The sorted unique values. - /// - public NDarray unique(int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("unique", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Find the unique elements of an array.

- /// - /// Returns the sorted unique elements of an array.

- /// There are three optional - /// outputs in addition to the unique elements: - /// - /// Notes - /// - /// When an axis is specified the subarrays indexed by the axis are sorted.

- /// - /// This is done by making the specified axis the first dimension of the array - /// and then flattening the subarrays in C order.

- /// The flattened subarrays are - /// then viewed as a structured type with each element given a label, with the - /// effect that we end up with a 1-D array of structured types that can be - /// treated in the same way as any other 1-D array.

- /// The result is that the - /// flattened subarrays are sorted in lexicographic order starting with the - /// first element. - /// - /// - /// If True, also return the indices of ar (along the specified axis, - /// if provided, or in the flattened array) that result in the unique array. - /// - /// - /// If True, also return the indices of the unique array (for the specified - /// axis, if provided) that can be used to reconstruct ar. - /// - /// - /// If True, also return the number of times each unique item appears - /// in ar. - /// - /// - /// The axis to operate on.

- /// If None, ar will be flattened.

- /// If an integer, - /// the subarrays indexed by the given axis will be flattened and treated - /// as the elements of a 1-D array with the dimension of the given axis, - /// see the notes for more details.

- /// Object arrays or structured arrays - /// that contain objects are not supported if the axis kwarg is used.

- /// The - /// default is None. - /// - /// - /// The sorted unique values. - /// - public NDarray[] unique(bool return_index, bool return_inverse, bool return_counts, int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (return_index!=null) kwargs["return_index"]=ToPython(return_index); - if (return_inverse!=null) kwargs["return_inverse"]=ToPython(return_inverse); - if (return_counts!=null) kwargs["return_counts"]=ToPython(return_counts); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("unique", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Reverse the order of elements in an array along the given axis.

- /// - /// The shape of the array is preserved, but the elements are reordered.

- /// - /// Notes - /// - /// flip(m, 0) is equivalent to flipud(m).

- /// - /// flip(m, 1) is equivalent to fliplr(m).

- /// - /// flip(m, n) corresponds to m[...,::-1,...] with ::-1 at position n.

- /// - /// flip(m) corresponds to m[::-1,::-1,...,::-1] with ::-1 at all - /// positions.

- /// - /// flip(m, (0, 1)) corresponds to m[::-1,::-1,...] with ::-1 at - /// position 0 and position 1. - /// - /// - /// Axis or axes along which to flip over.

- /// The default, - /// axis=None, will flip over all of the axes of the input array.

- /// - /// If axis is negative it counts from the last to the first axis.

- /// - /// If axis is a tuple of ints, flipping is performed on all of the axes - /// specified in the tuple. - /// - /// - /// A view of m with the entries of axis reversed.

- /// Since a view is - /// returned, this operation is done in constant time. - /// - public NDarray flip(Axis axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("flip", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Flip array in the left/right direction.

- /// - /// Flip the entries in each row in the left/right direction.

- /// - /// Columns are preserved, but appear in a different order than before.

- /// - /// Notes - /// - /// Equivalent to m[:,::-1].

- /// Requires the array to be at least 2-D. - /// - /// - /// A view of m with the columns reversed.

- /// Since a view - /// is returned, this operation is . - /// - public NDarray fliplr() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("fliplr"); - return ToCsharp(py); - } - - /// - /// Flip array in the up/down direction.

- /// - /// Flip the entries in each column in the up/down direction.

- /// - /// Rows are preserved, but appear in a different order than before.

- /// - /// Notes - /// - /// Equivalent to m[::-1,...].

- /// - /// Does not require the array to be two-dimensional. - /// - /// - /// A view of m with the rows reversed.

- /// Since a view is - /// returned, this operation is . - /// - public NDarray flipud() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("flipud"); - return ToCsharp(py); - } - - /// - /// Roll array elements along a given axis.

- /// - /// Elements that roll beyond the last position are re-introduced at - /// the first.

- /// - /// Notes - /// - /// Supports rolling over multiple dimensions simultaneously. - /// - /// - /// The number of places by which elements are shifted.

- /// If a tuple, - /// then axis must be a tuple of the same size, and each of the - /// given axes is shifted by the corresponding number.

- /// If an int - /// while axis is a tuple of ints, then the same value is used for - /// all given axes. - /// - /// - /// Axis or axes along which elements are shifted.

- /// By default, the - /// array is flattened before shifting, after which the original - /// shape is restored. - /// - /// - /// Output array, with the same shape as a. - /// - public NDarray roll(int[] shift, Axis axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - shift, - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("roll", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Rotate an array by 90 degrees in the plane specified by axes.

- /// - /// Rotation direction is from the first towards the second axis.

- /// - /// Notes - /// - /// rot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1)) - /// rot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1)) - /// - /// - /// Number of times the array is rotated by 90 degrees. - /// - /// - /// The array is rotated in the plane defined by the axes.

- /// - /// Axes must be different. - /// - /// - /// A rotated view of m. - /// - public NDarray rot90(int k = 1, int[] axes = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (k!=1) kwargs["k"]=ToPython(k); - if (axes!=null) kwargs["axes"]=ToPython(axes); - dynamic py = __self__.InvokeMethod("rot90", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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 &. - /// - /// - /// Only integer and boolean types are handled. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Result.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray bitwise_and(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("bitwise_and", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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 |. - /// - /// - /// Only integer and boolean types are handled. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Result.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray bitwise_or(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("bitwise_or", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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 ^. - /// - /// - /// Only integer and boolean types are handled. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Result.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray bitwise_xor(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("bitwise_xor", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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 - /// to . - /// - /// Notes - /// - /// bitwise_not is an alias for invert: - /// - /// References - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Result.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray invert(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("invert", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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. - /// - /// - /// Number of bits to remove at the right of x1. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Return x1 with bits shifted x2 times to the right.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray right_shift(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("right_shift", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Packs the elements of a binary-valued array into bits in a uint8 array.

- /// - /// The result is padded to full bytes by inserting zero bits at the end. - /// - /// - /// The dimension over which bit-packing is done.

- /// - /// None implies packing the flattened array. - /// - /// - /// Array of type uint8 whose elements represent bits corresponding to the - /// logical (0 or nonzero) value of the input elements.

- /// The shape of - /// packed has the same number of dimensions as the input (unless axis - /// is None, in which case the output is 1-D). - /// - public NDarray packbits(int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("packbits", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Unpacks elements of a uint8 array into a binary-valued output array.

- /// - /// Each element of myarray represents a bit-field that should be unpacked - /// into a binary-valued output array.

- /// The shape of the output array is either - /// 1-D (if axis is None) or the same shape as the input array with unpacking - /// done along the axis specified. - /// - /// - /// The dimension over which bit-unpacking is done.

- /// - /// None implies unpacking the flattened array. - /// - /// - /// The elements are binary-valued (0 or 1). - /// - public NDarray unpackbits(int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("unpackbits", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// For scalar a, returns the data type with the smallest size - /// and smallest scalar kind which can hold its value.

- /// For non-scalar - /// array a, returns the vector’s dtype unmodified.

- /// - /// Floating point values are not demoted to integers, - /// and complex values are not demoted to floats.

- /// - /// Notes - /// - /// - /// The minimal data type. - /// - public Dtype min_scalar_type() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("min_scalar_type"); - return ToCsharp(py); - } - - /// - /// Return a scalar type which is common to the input arrays.

- /// - /// The return type will always be an inexact (i.e.

- /// floating point) scalar - /// type, even if all the arrays are integer arrays.

- /// If one of the inputs is - /// an integer array, the minimum precision type that is returned is a - /// 64-bit floating point dtype.

- /// - /// All input arrays except int64 and uint64 can be safely cast to the - /// returned dtype without loss of information. - /// - /// - /// Input arrays. - /// - /// - /// Data type code. - /// - public Dtype common_type(NDarray array1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - array1, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("common_type", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Modified Bessel function of the first kind, order 0.

- /// - /// Usually denoted . This function does broadcast, but will not - /// “up-cast” int dtype arguments unless accompanied by at least one float or - /// complex dtype argument (see Raises below).

- /// - /// Notes - /// - /// We use the algorithm published by Clenshaw [1] and referenced by - /// Abramowitz and Stegun [2], for which the function domain is - /// partitioned into the two intervals [0,8] and (8,inf), and Chebyshev - /// polynomial expansions are employed in each interval.

- /// Relative error on - /// the domain [0,30] using IEEE arithmetic is documented [3] as having a - /// peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).

- /// - /// References - /// - /// - /// The modified Bessel function evaluated at each of the elements of x. - /// - public NDarray i0() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("i0"); - return ToCsharp(py); - } - - /// - /// Compute the future value.

- /// - /// Notes - /// - /// The future value is computed by solving the equation: - /// - /// or, when rate == 0: - /// - /// References - /// - /// - /// Number of compounding periods - /// - /// - /// Payment - /// - /// - /// Present value - /// - /// - /// When payments are due (‘begin’ (1) or ‘end’ (0)).

- /// - /// Defaults to {‘end’, 0}. - /// - /// - /// Future values.

- /// If all input is scalar, returns a scalar float.

- /// If - /// any input is array_like, returns future values for each input element.

- /// - /// If multiple inputs are array_like, they all must have the same shape. - /// - public NDarray fv(NDarray nper, NDarray pmt, NDarray pv, string @when = "end") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - nper, - pmt, - pv, - }); - var kwargs=new PyDict(); - if (@when!="end") kwargs["when"]=ToPython(@when); - dynamic py = __self__.InvokeMethod("fv", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the present value.

- /// - /// Notes - /// - /// The present value is computed by solving the equation: - /// - /// or, when rate = 0: - /// - /// for pv, which is then returned.

- /// - /// References - /// - /// - /// Number of compounding periods - /// - /// - /// Payment - /// - /// - /// Future value - /// - /// - /// When payments are due (‘begin’ (1) or ‘end’ (0)) - /// - /// - /// Present value of a series of payments or investments. - /// - public NDarray pv(NDarray nper, NDarray pmt, NDarray fv = null, string @when = "end") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - nper, - pmt, - }); - var kwargs=new PyDict(); - if (fv!=null) kwargs["fv"]=ToPython(fv); - if (@when!="end") kwargs["when"]=ToPython(@when); - dynamic py = __self__.InvokeMethod("pv", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the payment against loan principal plus interest.

- /// - /// Notes - /// - /// The payment is computed by solving the equation: - /// - /// or, when rate == 0: - /// - /// for pmt.

- /// - /// Note that computing a monthly mortgage payment is only - /// one use for this function.

- /// For example, pmt returns the - /// periodic deposit one must make to achieve a specified - /// future balance given an initial deposit, a fixed, - /// periodically compounded interest rate, and the total - /// number of periods.

- /// - /// References - /// - /// - /// Number of compounding periods - /// - /// - /// Present value - /// - /// - /// Future value (default = 0) - /// - /// - /// When payments are due (‘begin’ (1) or ‘end’ (0)) - /// - /// - /// Payment against loan plus interest.

- /// If all input is scalar, returns a - /// scalar float.

- /// If any input is array_like, returns payment for each - /// input element.

- /// If multiple inputs are array_like, they all must have - /// the same shape. - /// - public NDarray pmt(NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - nper, - pv, - }); - var kwargs=new PyDict(); - if (fv!=null) kwargs["fv"]=ToPython(fv); - if (@when!="end") kwargs["when"]=ToPython(@when); - dynamic py = __self__.InvokeMethod("pmt", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the payment against loan principal. - /// - /// - /// Amount paid against the loan changes.

- /// The per is the period of - /// interest. - /// - /// - /// Number of compounding periods - /// - /// - /// Present value - /// - /// - /// Future value - /// - /// - /// When payments are due (‘begin’ (1) or ‘end’ (0)) - /// - public void ppmt(NDarray per, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - per, - nper, - pv, - }); - var kwargs=new PyDict(); - if (fv!=null) kwargs["fv"]=ToPython(fv); - if (@when!="end") kwargs["when"]=ToPython(@when); - dynamic py = __self__.InvokeMethod("ppmt", pyargs, kwargs); - } - - /// - /// Compute the interest portion of a payment.

- /// - /// Notes - /// - /// The total payment is made up of payment against principal plus interest.

- /// - /// pmt = ppmt + ipmt - /// - /// - /// Interest paid against the loan changes during the life or the loan.

- /// - /// The per is the payment period to calculate the interest amount. - /// - /// - /// Number of compounding periods - /// - /// - /// Present value - /// - /// - /// Future value - /// - /// - /// When payments are due (‘begin’ (1) or ‘end’ (0)).

- /// - /// Defaults to {‘end’, 0}. - /// - /// - /// Interest portion of payment.

- /// If all input is scalar, returns a scalar - /// float.

- /// If any input is array_like, returns interest payment for each - /// input element.

- /// If multiple inputs are array_like, they all must have - /// the same shape. - /// - public NDarray ipmt(NDarray per, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - per, - nper, - pv, - }); - var kwargs=new PyDict(); - if (fv!=null) kwargs["fv"]=ToPython(fv); - if (@when!="end") kwargs["when"]=ToPython(@when); - dynamic py = __self__.InvokeMethod("ipmt", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the Internal Rate of Return (IRR).

- /// - /// This is the “average” periodically compounded rate of return - /// that gives a net present value of 0.0; for a more complete explanation, - /// see Notes below.

- /// - /// decimal.Decimal type is not supported.

- /// - /// Notes - /// - /// The IRR is perhaps best understood through an example (illustrated - /// using np.irr in the Examples section below).

- /// Suppose one invests 100 - /// units and then makes the following withdrawals at regular (fixed) - /// intervals: 39, 59, 55, 20. Assuming the ending value is 0, one’s 100 - /// unit investment yields 173 units; however, due to the combination of - /// compounding and the periodic withdrawals, the “average” rate of return - /// is neither simply 0.73/4 nor (1.73)^0.25-1. Rather, it is the solution - /// (for ) of the equation: - /// - /// In general, for values , - /// irr is the solution of the equation: [G] - /// - /// References - /// - /// - /// Internal Rate of Return for periodic input values. - /// - public float irr() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("irr"); - return ToCsharp(py); - } - - /// - /// Modified internal rate of return. - /// - /// - /// Interest rate paid on the cash flows - /// - /// - /// Interest rate received on the cash flows upon reinvestment - /// - /// - /// Modified internal rate of return - /// - public float mirr(ValueType finance_rate, ValueType reinvest_rate) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - finance_rate, - reinvest_rate, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("mirr", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the number of periodic payments.

- /// - /// decimal.Decimal type is not supported.

- /// - /// Notes - /// - /// The number of periods nper is computed by solving the equation: - /// - /// but if rate = 0 then: - /// - /// - /// Payment - /// - /// - /// Present value - /// - /// - /// Future value - /// - /// - /// When payments are due (‘begin’ (1) or ‘end’ (0)) - /// - public void nper(NDarray pmt, NDarray pv, NDarray fv = null, string @when = "end") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - pmt, - pv, - }); - var kwargs=new PyDict(); - if (fv!=null) kwargs["fv"]=ToPython(fv); - if (@when!="end") kwargs["when"]=ToPython(@when); - dynamic py = __self__.InvokeMethod("nper", pyargs, kwargs); - } - - /// - /// Compute the rate of interest per period.

- /// - /// Notes - /// - /// The rate of interest is computed by iteratively solving the - /// (non-linear) equation: - /// - /// for rate.

- /// - /// References - /// - /// Wheeler, D.

- /// A., E.

- /// Rathke, and R.

- /// Weir (Eds.) (2009, May).

- /// Open Document - /// Format for Office Applications (OpenDocument)v1.2, Part 2: Recalculated - /// Formula (OpenFormula) Format - Annotated Version, Pre-Draft 12. - /// Organization for the Advancement of Structured Information Standards - /// (OASIS).

- /// Billerica, MA, USA.

- /// [ODT Document].

- /// Available: - /// http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula - /// OpenDocument-formula-20090508.odt - /// - /// - /// Payment - /// - /// - /// Present value - /// - /// - /// Future value - /// - /// - /// When payments are due (‘begin’ (1) or ‘end’ (0)) - /// - /// - /// Starting guess for solving the rate of interest, default 0.1 - /// - /// - /// Required tolerance for the solution, default 1e-6 - /// - /// - /// Maximum iterations in finding the solution - /// - public void rate(NDarray pmt, NDarray pv, NDarray fv, string @when = "end", double? guess = null, double? tol = null, int? maxiter = 100) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - pmt, - pv, - fv, - }); - var kwargs=new PyDict(); - if (@when!="end") kwargs["when"]=ToPython(@when); - if (guess!=null) kwargs["guess"]=ToPython(guess); - if (tol!=null) kwargs["tol"]=ToPython(tol); - if (maxiter!=100) kwargs["maxiter"]=ToPython(maxiter); - dynamic py = __self__.InvokeMethod("rate", pyargs, kwargs); - } - - /// - /// Return the indices of the elements that are non-zero.

- /// - /// Returns a tuple of arrays, one for each dimension of a, - /// containing the indices of the non-zero elements in that - /// dimension.

- /// The values in a are always tested and returned in - /// row-major, C-style order.

- /// The corresponding non-zero - /// values can be obtained with: - /// - /// To group the indices by element, rather than dimension, use: - /// - /// The result of this is always a 2-D array, with a row for - /// each non-zero element. - /// - /// - /// Indices of elements that are non-zero. - /// - public NDarray[] nonzero() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("nonzero"); - return ToCsharp(py); - } - - /// - /// Return elements chosen from x or y depending on condition.

- /// - /// Notes - /// - /// If all the arrays are 1-D, where is equivalent to: - /// - /// - /// Values from which to choose.

- /// x, y and condition need to be - /// broadcastable to some shape. - /// - /// - /// Values from which to choose.

- /// x, y and condition need to be - /// broadcastable to some shape. - /// - /// - /// An array with elements from x where condition is True, and elements - /// from y elsewhere. - /// - public NDarray @where(NDarray y, NDarray x) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - y, - x, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("where", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return elements chosen from x or y depending on condition.

- /// - /// Notes - /// - /// If all the arrays are 1-D, where is equivalent to: - /// - /// - /// An array with elements from x where condition is True, and elements - /// from y elsewhere. - /// - public NDarray[] @where() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("where"); - return ToCsharp(py); - } - - /// - /// Converts a flat index or array of flat indices into a tuple - /// of coordinate arrays. - /// - /// - /// The shape of the array to use for unraveling indices. - /// - /// - /// Determines whether the indices should be viewed as indexing in - /// row-major (C-style) or column-major (Fortran-style) order. - /// - /// - /// Each array in the tuple has the same shape as the indices - /// array. - /// - public NDarray[] unravel_index(Shape shape, string order = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - shape, - }); - var kwargs=new PyDict(); - if (order!=null) kwargs["order"]=ToPython(order); - dynamic py = __self__.InvokeMethod("unravel_index", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the indices to access the main diagonal of an n-dimensional array.

- /// - /// See diag_indices for full details.

- /// - /// Notes - /// - public void diag_indices_from() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("diag_indices_from"); - } - - /// - /// Return the indices for the lower-triangle of arr.

- /// - /// See tril_indices for full details.

- /// - /// Notes - /// - /// - /// Diagonal offset (see tril for details). - /// - public void tril_indices_from(int? k = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (k!=0) kwargs["k"]=ToPython(k); - dynamic py = __self__.InvokeMethod("tril_indices_from", pyargs, kwargs); - } - - /// - /// Return the indices for the upper-triangle of arr.

- /// - /// See triu_indices for full details.

- /// - /// Notes - /// - /// - /// Diagonal offset (see triu for details). - /// - /// - /// Indices for the upper-triangle of arr. - /// - public NDarray[] triu_indices_from(int? k = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (k!=0) kwargs["k"]=ToPython(k); - dynamic py = __self__.InvokeMethod("triu_indices_from", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Take values from the input array by matching 1d index and data slices.

- /// - /// This iterates over matching 1d slices oriented along the specified axis in - /// the index and data arrays, and uses the former to look up values in the - /// latter.

- /// These slices can be different lengths.

- /// - /// Functions returning an index along an axis, like argsort and - /// argpartition, produce suitable indices for this function.

- /// - /// Notes - /// - /// This is equivalent to (but faster than) the following use of ndindex and - /// s_, which sets each of ii and kk to a tuple of indices: - /// - /// Equivalently, eliminating the inner loop, the last two lines would be: - /// - /// - /// Indices to take along each 1d slice of arr.

- /// This must match the - /// dimension of arr, but dimensions Ni and Nj only need to broadcast - /// against arr. - /// - /// - /// The axis to take 1d slices along.

- /// If axis is None, the input array is - /// treated as if it had first been flattened to 1d, for consistency with - /// sort and argsort. - /// - public NDarray take_along_axis(NDarray indices, int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - indices, - axis, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("take_along_axis", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return specified diagonals.

- /// - /// If a is 2-D, returns the diagonal of a with the given offset, - /// i.e., the collection of elements of the form a[i, i+offset].

- /// If - /// a has more than two dimensions, then the axes specified by axis1 - /// and axis2 are used to determine the 2-D sub-array whose diagonal is - /// returned.

- /// The shape of the resulting array can be determined by - /// removing axis1 and axis2 and appending an index to the right equal - /// to the size of the resulting diagonals.

- /// - /// In versions of NumPy prior to 1.7, this function always returned a new, - /// independent array containing a copy of the values in the diagonal.

- /// - /// In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal, - /// but depending on this fact is deprecated.

- /// Writing to the resulting - /// array continues to work as it used to, but a FutureWarning is issued.

- /// - /// Starting in NumPy 1.9 it returns a read-only view on the original array.

- /// - /// Attempting to write to the resulting array will produce an error.

- /// - /// In some future release, it will return a read/write view and writing to - /// the returned array will alter your original array.

- /// The returned array - /// will have the same type as the input array.

- /// - /// If you don’t write to the array returned by this function, then you can - /// just ignore all of the above.

- /// - /// If you depend on the current behavior, then we suggest copying the - /// returned array explicitly, i.e., use np.diagonal(a).copy() instead - /// of just np.diagonal(a).

- /// This will work with both past and future - /// versions of NumPy. - /// - /// - /// Offset of the diagonal from the main diagonal.

- /// Can be positive or - /// negative.

- /// Defaults to main diagonal (0). - /// - /// - /// Axis to be used as the first axis of the 2-D sub-arrays from which - /// the diagonals should be taken.

- /// Defaults to first axis (0). - /// - /// - /// Axis to be used as the second axis of the 2-D sub-arrays from - /// which the diagonals should be taken.

- /// Defaults to second axis (1). - /// - /// - /// If a is 2-D, then a 1-D array containing the diagonal and of the - /// same type as a is returned unless a is a matrix, in which case - /// a 1-D array rather than a (2-D) matrix is returned in order to - /// maintain backward compatibility.

- /// - /// If a.ndim > 2, then the dimensions specified by axis1 and axis2 - /// are removed, and a new axis inserted at the end corresponding to the - /// diagonal. - /// - public NDarray diagonal(int? offset = 0, int? axis1 = 0, int? axis2 = 1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (offset!=0) kwargs["offset"]=ToPython(offset); - if (axis1!=0) kwargs["axis1"]=ToPython(axis1); - if (axis2!=1) kwargs["axis2"]=ToPython(axis2); - dynamic py = __self__.InvokeMethod("diagonal", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Change elements of an array based on conditional and input values.

- /// - /// Similar to np.copyto(arr, vals, where=mask), the difference is that - /// place uses the first N elements of vals, where N is the number of - /// True values in mask, while copyto uses the elements where mask - /// is True.

- /// - /// Note that extract does the exact opposite of place. - /// - /// - /// Boolean mask array.

- /// Must have the same size as a. - /// - /// - /// Values to put into a.

- /// Only the first N elements are used, where - /// N is the number of True values in mask.

- /// If vals is smaller - /// than N, it will be repeated, and if elements of a are to be masked, - /// this sequence must be non-empty. - /// - public void place(NDarray mask, NDarray vals) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - mask, - vals, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("place", pyargs, kwargs); - } - - /// - /// Replaces specified elements of an array with given values.

- /// - /// The indexing works on the flattened target array.

- /// put is roughly - /// equivalent to: - /// - /// - /// Target indices, interpreted as integers. - /// - /// - /// Values to place in a at target indices.

- /// If v is shorter than - /// ind it will be repeated as necessary. - /// - /// - /// Specifies how out-of-bounds indices will behave.

- /// - /// ‘clip’ mode means that all indices that are too large are replaced - /// by the index that addresses the last element along that axis.

- /// Note - /// that this disables indexing with negative numbers. - /// - public void put(NDarray ind, NDarray v, string mode = "raise") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - ind, - v, - }); - var kwargs=new PyDict(); - if (mode!="raise") kwargs["mode"]=ToPython(mode); - dynamic py = __self__.InvokeMethod("put", pyargs, kwargs); - } - - /// - /// Put values into the destination array by matching 1d index and data slices.

- /// - /// This iterates over matching 1d slices oriented along the specified axis in - /// the index and data arrays, and uses the former to place values into the - /// latter.

- /// These slices can be different lengths.

- /// - /// Functions returning an index along an axis, like argsort and - /// argpartition, produce suitable indices for this function.

- /// - /// Notes - /// - /// This is equivalent to (but faster than) the following use of ndindex and - /// s_, which sets each of ii and kk to a tuple of indices: - /// - /// Equivalently, eliminating the inner loop, the last two lines would be: - /// - /// - /// Indices to change along each 1d slice of arr.

- /// This must match the - /// dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast - /// against arr. - /// - /// - /// values to insert at those indices.

- /// Its shape and dimension are - /// broadcast to match that of indices. - /// - /// - /// The axis to take 1d slices along.

- /// If axis is None, the destination - /// array is treated as if a flattened 1d view had been created of it. - /// - public void put_along_axis(NDarray indices, NDarray[] values, int axis) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - indices, - values, - axis, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("put_along_axis", pyargs, kwargs); - } - - /// - /// Changes elements of an array based on conditional and input values.

- /// - /// Sets a.flat[n] = values[n] for each n where mask.flat[n]==True.

- /// - /// If values is not the same size as a and mask then it will repeat.

- /// - /// This gives behavior different from a[mask] = values. - /// - /// - /// Boolean mask array.

- /// It has to be the same shape as a. - /// - /// - /// Values to put into a where mask is True.

- /// If values is smaller - /// than a it will be repeated. - /// - public void putmask(NDarray mask, NDarray values) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - mask, - values, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("putmask", pyargs, kwargs); - } - - /// - /// Fill the main diagonal of the given array of any dimensionality.

- /// - /// For an array a with a.ndim >= 2, the diagonal is the list of - /// locations with indices a[i, ..., i] all identical.

- /// This function - /// modifies the input array in-place, it does not return a value.

- /// - /// Notes - /// - /// This functionality can be obtained via diag_indices, but internally - /// this version uses a much faster implementation that never constructs the - /// indices and uses simple slicing. - /// - /// - /// Value to be written on the diagonal, its type must be compatible with - /// that of the array a. - /// - /// - /// For tall matrices in NumPy version up to 1.6.2, the - /// diagonal “wrapped” after N columns.

- /// You can have this behavior - /// with this option.

- /// This affects only tall matrices. - /// - public void fill_diagonal(ValueType val, bool wrap = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - val, - }); - var kwargs=new PyDict(); - if (wrap!=false) kwargs["wrap"]=ToPython(wrap); - dynamic py = __self__.InvokeMethod("fill_diagonal", pyargs, kwargs); - } - - /* - /// - /// Efficient multi-dimensional iterator object to iterate over arrays.

- /// - /// To get started using this object, see the - /// introductory guide to array iteration.

- /// - /// Notes - /// - /// nditer supersedes flatiter.

- /// The iterator implementation behind - /// nditer is also exposed by the NumPy C API.

- /// - /// The Python exposure supplies two iteration interfaces, one which follows - /// the Python iterator protocol, and another which mirrors the C-style - /// do-while pattern.

- /// The native Python approach is better in most cases, but - /// if you need the iterator’s coordinates or index, use the C-style pattern. - /// - /// - /// Flags to control the behavior of the iterator. - /// - /// - /// This is a list of flags for each operand.

- /// At minimum, one of - /// “readonly”, “readwrite”, or “writeonly” must be specified. - /// - /// - /// The required data type(s) of the operands.

- /// If copying or buffering - /// is enabled, the data will be converted to/from their original types. - /// - /// - /// Controls the iteration order.

- /// ‘C’ means C order, ‘F’ means - /// Fortran order, ‘A’ means ‘F’ order if all the arrays are Fortran - /// contiguous, ‘C’ order otherwise, and ‘K’ means as close to the - /// order the array elements appear in memory as possible.

- /// This also - /// affects the element memory order of “allocate” operands, as they - /// are allocated to be compatible with iteration order.

- /// - /// Default is ‘K’. - /// - /// - /// Controls what kind of data casting may occur when making a copy - /// or buffering.

- /// Setting this to ‘unsafe’ is not recommended, - /// as it can adversely affect accumulations. - /// - /// - /// If provided, is a list of ints or None for each operands.

- /// - /// The list of axes for an operand is a mapping from the dimensions - /// of the iterator to the dimensions of the operand.

- /// A value of - /// -1 can be placed for entries, causing that dimension to be - /// treated as “newaxis”. - /// - /// - /// The desired shape of the iterator.

- /// This allows “allocate” operands - /// with a dimension mapped by op_axes not corresponding to a dimension - /// of a different operand to get a value not equal to 1 for that - /// dimension. - /// - /// - /// When buffering is enabled, controls the size of the temporary - /// buffers.

- /// Set to 0 for the default value. - /// - public void nditer(string[] flags = null, list of list of str op_flags = null, dtype or tuple of dtype(s) op_dtypes = null, string order = null, string casting = null, list of list of ints op_axes = null, tuple of ints itershape = null, int? buffersize = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (flags!=null) kwargs["flags"]=ToPython(flags); - if (op_flags!=null) kwargs["op_flags"]=ToPython(op_flags); - if (op_dtypes!=null) kwargs["op_dtypes"]=ToPython(op_dtypes); - if (order!=null) kwargs["order"]=ToPython(order); - if (casting!=null) kwargs["casting"]=ToPython(casting); - if (op_axes!=null) kwargs["op_axes"]=ToPython(op_axes); - if (itershape!=null) kwargs["itershape"]=ToPython(itershape); - if (buffersize!=null) kwargs["buffersize"]=ToPython(buffersize); - dynamic py = __self__.InvokeMethod("nditer", pyargs, kwargs); - } - */ - - /// - /// Multidimensional index iterator.

- /// - /// Return an iterator yielding pairs of array coordinates and values. - /// - public void ndenumerate() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("ndenumerate"); - } - - /* - /// - /// Create nditers for use in nested loops - /// - /// Create a tuple of nditer objects which iterate in nested loops over - /// different axes of the op argument.

- /// The first iterator is used in the - /// outermost loop, the last in the innermost loop.

- /// Advancing one will change - /// the subsequent iterators to point at its new element. - /// - /// - /// Each item is used as an “op_axes” argument to an nditer - /// - /// - /// An nditer for each item in axes, outermost first - /// - public tuple of nditer nested_iters(params int[] axes) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axes!=null) kwargs["axes"]=ToPython(axes); - dynamic py = __self__.InvokeMethod("nested_iters", pyargs, kwargs); - return ToCsharp(py); - } - */ - - /* - /// - /// Return a string representation of an array.

- /// - /// Notes - /// - /// If a formatter is specified for a certain type, the precision keyword is - /// ignored for that type.

- /// - /// This is a very flexible function; array_repr and array_str are using - /// array2string internally so keywords with the same name should work - /// identically in all three functions. - /// - /// - /// The maximum number of columns the string should span.

- /// Newline - /// characters splits the string appropriately after array elements. - /// - /// - /// Floating point precision.

- /// Default is the current printing - /// precision (usually 8), which can be altered using set_printoptions. - /// - /// - /// Represent very small numbers as zero.

- /// A number is “very small” if it - /// is smaller than the current printing precision. - /// - /// - /// Inserted between elements. - /// - /// - /// The length of the prefix and suffix strings are used to respectively - /// align and wrap the output.

- /// An array is typically printed as: - /// - /// The output is left-padded by the length of the prefix string, and - /// wrapping is forced at the column max_line_width - len(suffix).

- /// - /// It should be noted that the content of prefix and suffix strings are - /// not included in the output. - /// - /// - /// 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: - /// - /// Other keys that can be used to set a group of types at once are: - /// - /// - /// Total number of array elements which trigger summarization - /// rather than full repr. - /// - /// - /// Number of array items in summary at beginning and end of - /// each dimension. - /// - /// - /// 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. - /// - /// - /// Controls the interpretation of the precision option for - /// floating-point types.

- /// Can take the following values: - /// - /// - /// 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.

- /// If set to - /// False, disables legacy mode.

- /// Unrecognized strings will be ignored - /// with a warning for forward compatibility. - /// - /// - /// String representation of the array. - /// - public string array2string(int? max_line_width = null, int? precision = null, bool? suppress_small = null, string separator = " ", string prefix = "", string suffix = "", dict of callables formatter = null, int? threshold = null, int? edgeitems = null, string sign = null, string floatmode = null, string or False legacy = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (max_line_width!=null) kwargs["max_line_width"]=ToPython(max_line_width); - if (precision!=null) kwargs["precision"]=ToPython(precision); - if (suppress_small!=null) kwargs["suppress_small"]=ToPython(suppress_small); - if (separator!=" ") kwargs["separator"]=ToPython(separator); - if (prefix!="") kwargs["prefix"]=ToPython(prefix); - if (suffix!="") kwargs["suffix"]=ToPython(suffix); - if (formatter!=null) kwargs["formatter"]=ToPython(formatter); - if (threshold!=null) kwargs["threshold"]=ToPython(threshold); - if (edgeitems!=null) kwargs["edgeitems"]=ToPython(edgeitems); - if (sign!=null) kwargs["sign"]=ToPython(sign); - if (floatmode!=null) kwargs["floatmode"]=ToPython(floatmode); - if (legacy!=null) kwargs["legacy"]=ToPython(legacy); - dynamic py = __self__.InvokeMethod("array2string", pyargs, kwargs); - return ToCsharp(py); - } - */ - - /// - /// Return the string representation of an array. - /// - /// - /// The maximum number of columns the string should span.

- /// Newline - /// characters split the string appropriately after array elements. - /// - /// - /// Floating point precision.

- /// Default is the current printing precision - /// (usually 8), which can be altered using set_printoptions. - /// - /// - /// Represent very small numbers as zero, default is False.

- /// Very small - /// is defined by precision, if the precision is 8 then - /// numbers smaller than 5e-9 are represented as zero. - /// - /// - /// The string representation of an array. - /// - public string array_repr(int? max_line_width = null, int? precision = null, bool? suppress_small = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (max_line_width!=null) kwargs["max_line_width"]=ToPython(max_line_width); - if (precision!=null) kwargs["precision"]=ToPython(precision); - if (suppress_small!=null) kwargs["suppress_small"]=ToPython(suppress_small); - dynamic py = __self__.InvokeMethod("array_repr", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return a string representation of the data in an array.

- /// - /// The data in the array is returned as a single string.

- /// This function is - /// similar to array_repr, the difference being that array_repr also - /// returns information on the kind of array and its data type. - /// - /// - /// Inserts newlines if text is longer than max_line_width.

- /// The - /// default is, indirectly, 75. - /// - /// - /// Floating point precision.

- /// Default is the current printing precision - /// (usually 8), which can be altered using set_printoptions. - /// - /// - /// Represent numbers “very close” to zero as zero; default is False.

- /// - /// Very close is defined by precision: if the precision is 8, e.g., - /// numbers smaller (in absolute value) than 5e-9 are represented as - /// zero. - /// - public void array_str(int? max_line_width = null, int? precision = null, bool? suppress_small = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (max_line_width!=null) kwargs["max_line_width"]=ToPython(max_line_width); - if (precision!=null) kwargs["precision"]=ToPython(precision); - if (suppress_small!=null) kwargs["suppress_small"]=ToPython(suppress_small); - dynamic py = __self__.InvokeMethod("array_str", pyargs, kwargs); - } - - /// - /// Dot product of two arrays.

- /// Specifically, - /// - /// - /// Second argument. - /// - /// - /// Output argument.

- /// This must have the exact kind that would be returned - /// if it was not used.

- /// In particular, it must have the right type, must be - /// C-contiguous, and its dtype must be the dtype that would be returned - /// for dot(a,b).

- /// This is a performance feature.

- /// Therefore, if these - /// conditions are not met, an exception is raised, instead of attempting - /// to be flexible. - /// - /// - /// Returns the dot product of a and b.

- /// If a and b are both - /// scalars or both 1-D arrays then a scalar is returned; otherwise - /// an array is returned.

- /// - /// If out is given, then it is returned. - /// - public NDarray dot(NDarray b, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - b, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("dot", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the dot product of two vectors.

- /// - /// The vdot(a, b) function handles complex numbers differently than - /// dot(a, b).

- /// If the first argument is complex the complex conjugate - /// of the first argument is used for the calculation of the dot product.

- /// - /// Note that vdot handles multidimensional arrays differently than dot: - /// it does not perform a matrix product, but flattens input arguments - /// to 1-D vectors first.

- /// Consequently, it should only be used for vectors. - /// - /// - /// Second argument to the dot product. - /// - /// - /// Dot product of a and b.

- /// Can be an int, float, or - /// complex depending on the types of a and b. - /// - public NDarray vdot(NDarray b) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - b, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("vdot", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Inner product of two arrays.

- /// - /// Ordinary inner product of vectors for 1-D arrays (without complex - /// conjugation), in higher dimensions a sum product over the last axes.

- /// - /// Notes - /// - /// For vectors (1-D arrays) it computes the ordinary inner-product: - /// - /// More generally, if ndim(a) = r > 0 and ndim(b) = s > 0: - /// - /// or explicitly: - /// - /// In addition a or b may be scalars, in which case: - /// - /// - /// If a and b are nonscalar, their last dimensions must match. - /// - /// - /// out.shape = a.shape[:-1] + b.shape[:-1] - /// - public NDarray inner(NDarray a) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("inner", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the outer product of two vectors.

- /// - /// Given two vectors, a = [a0, a1, ..., aM] and - /// b = [b0, b1, ..., bN], - /// the outer product [1] is: - /// - /// References - /// - /// - /// Second input vector.

- /// Input is flattened if - /// not already 1-dimensional. - /// - /// - /// A location where the result is stored - /// - /// - /// out[i, j] = a[i] * b[j] - /// - public NDarray outer(NDarray b, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - b, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("outer", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Matrix product of two arrays.

- /// - /// Notes - /// - /// The behavior depends on the arguments in the following way.

- /// - /// matmul differs from dot in two important ways: - /// - /// The matmul function implements the semantics of the @ operator introduced - /// in Python 3.5 following PEP465. - /// - /// - /// Input arrays, scalars not allowed. - /// - /// - /// 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. - /// - /// - /// The matrix product of the inputs.

- /// - /// This is a scalar only when both x1, x2 are 1-d vectors. - /// - public NDarray matmul(NDarray x1, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("matmul", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute tensor dot product along specified axes for arrays >= 1-D.

- /// - /// Given two tensors (arrays of dimension greater than or equal to one), - /// a and b, and an array_like object containing two array_like - /// objects, (a_axes, b_axes), sum the products of a’s and b’s - /// elements (components) over the axes specified by a_axes and - /// b_axes.

- /// The third argument can be a single non-negative - /// integer_like scalar, N; if it is such, then the last N - /// dimensions of a and the first N dimensions of b are summed - /// over.

- /// - /// Notes - /// - /// When axes is integer_like, the sequence for evaluation will be: first - /// the -Nth axis in a and 0th axis in b, and the -1th axis in a and - /// Nth axis in b last.

- /// - /// When there is more than one axis to sum over - and they are not the last - /// (first) axes of a (b) - the argument axes should consist of - /// two sequences of the same length, with the first axis to sum over given - /// first in both sequences, the second axis second, and so forth. - /// - /// - /// Tensors to “dot”. - /// - public NDarray tensordot(NDarray a, int[] axes = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a, - }); - var kwargs=new PyDict(); - if (axes!=null) kwargs["axes"]=ToPython(axes); - dynamic py = __self__.InvokeMethod("tensordot", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Kronecker product of two arrays.

- /// - /// Computes the Kronecker product, a composite array made of blocks of the - /// second array scaled by the first.

- /// - /// Notes - /// - /// The function assumes that the number of dimensions of a and b - /// are the same, if necessary prepending the smallest with ones.

- /// - /// If a.shape = (r0,r1,..,rN) and b.shape = (s0,s1,…,sN), - /// the Kronecker product has shape (r0*s0, r1*s1, …, rN*SN).

- /// - /// The elements are products of elements from a and b, organized - /// explicitly by: - /// - /// where: - /// - /// In the common 2-D case (N=1), the block structure can be visualized: - /// - public NDarray kron(NDarray a) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("kron", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the sum along diagonals of the array.

- /// - /// If a is 2-D, the sum along its diagonal with the given offset - /// is returned, i.e., the sum of elements a[i,i+offset] for all i.

- /// - /// If a has more than two dimensions, then the axes specified by axis1 and - /// axis2 are used to determine the 2-D sub-arrays whose traces are returned.

- /// - /// The shape of the resulting array is the same as that of a with axis1 - /// and axis2 removed. - /// - /// - /// Offset of the diagonal from the main diagonal.

- /// Can be both positive - /// and negative.

- /// Defaults to 0. - /// - /// - /// Axes to be used as the first and second axis of the 2-D sub-arrays - /// from which the diagonals should be taken.

- /// Defaults are the first two - /// axes of a. - /// - /// - /// Axes to be used as the first and second axis of the 2-D sub-arrays - /// from which the diagonals should be taken.

- /// Defaults are the first two - /// axes of a. - /// - /// - /// Determines the data-type of the returned array and of the accumulator - /// where the elements are summed.

- /// If dtype has the value None and a is - /// of integer type of precision less than the default integer - /// precision, then the default integer precision is used.

- /// Otherwise, - /// the precision is the same as that of a. - /// - /// - /// Array into which the output is placed.

- /// Its type is preserved and - /// it must be of the right shape to hold the output. - /// - /// - /// If a is 2-D, the sum along the diagonal is returned.

- /// If a has - /// larger dimensions, then an array of sums along diagonals is returned. - /// - public NDarray trace(int? offset = 0, int? axis2 = null, int? axis1 = null, Dtype dtype = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (offset!=0) kwargs["offset"]=ToPython(offset); - if (axis2!=null) kwargs["axis2"]=ToPython(axis2); - if (axis1!=null) kwargs["axis1"]=ToPython(axis1); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("trace", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Test whether all array elements along a given axis evaluate to True.

- /// - /// Notes - /// - /// Not a Number (NaN), positive infinity and negative infinity - /// evaluate to True because these are not equal to zero. - /// - /// - /// Axis or axes along which a logical AND reduction is performed.

- /// - /// The default (axis = None) is to perform a logical AND over all - /// the dimensions of the input array.

- /// axis may be negative, in - /// which case it counts from the last to the first axis.

- /// - /// If this is a tuple of ints, a reduction is performed on multiple - /// axes, instead of a single axis or all the axes as before. - /// - /// - /// Alternate output array in which to place the result.

- /// - /// It must have the same shape as the expected output and its - /// type is preserved (e.g., if dtype(out) is float, the result - /// will consist of 0.0’s and 1.0’s).

- /// See doc.ufuncs (Section - /// “Output arguments”) for more details. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the input array.

- /// - /// If the default value is passed, then keepdims will not be - /// passed through to the all method of sub-classes of - /// ndarray, however any non-default value will be.

- /// If the - /// sub-class’ method does not implement keepdims any - /// exceptions will be raised. - /// - /// - /// A new boolean or array is returned unless out is specified, - /// in which case a reference to out is returned. - /// - public NDarray all(Axis axis, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("all", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Test whether all array elements along a given axis evaluate to True.

- /// - /// Notes - /// - /// Not a Number (NaN), positive infinity and negative infinity - /// evaluate to True because these are not equal to zero. - /// - /// - /// A new boolean or array is returned unless out is specified, - /// in which case a reference to out is returned. - /// - public bool all() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("all"); - return ToCsharp(py); - } - - /// - /// Test whether any array element along a given axis evaluates to True.

- /// - /// Returns single boolean unless axis is not None - /// - /// Notes - /// - /// Not a Number (NaN), positive infinity and negative infinity evaluate - /// to True because these are not equal to zero. - /// - /// - /// Axis or axes along which a logical OR reduction is performed.

- /// - /// The default (axis = None) is to perform a logical OR over all - /// the dimensions of the input array.

- /// axis may be negative, in - /// which case it counts from the last to the first axis.

- /// - /// If this is a tuple of ints, a reduction is performed on multiple - /// axes, instead of a single axis or all the axes as before. - /// - /// - /// Alternate output array in which to place the result.

- /// It must have - /// the same shape as the expected output and its type is preserved - /// (e.g., if it is of type float, then it will remain so, returning - /// 1.0 for True and 0.0 for False, regardless of the type of a).

- /// - /// See doc.ufuncs (Section “Output arguments”) for details. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the input array.

- /// - /// If the default value is passed, then keepdims will not be - /// passed through to the any method of sub-classes of - /// ndarray, however any non-default value will be.

- /// If the - /// sub-class’ method does not implement keepdims any - /// exceptions will be raised. - /// - /// - /// A new boolean or ndarray is returned unless out is specified, - /// in which case a reference to out is returned. - /// - public NDarray any(Axis axis, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("any", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Test whether any array element along a given axis evaluates to True.

- /// - /// Returns single boolean unless axis is not None - /// - /// Notes - /// - /// Not a Number (NaN), positive infinity and negative infinity evaluate - /// to True because these are not equal to zero. - /// - /// - /// A new boolean or ndarray is returned unless out is specified, - /// in which case a reference to out is returned. - /// - public bool any() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("any"); - return ToCsharp(py); - } - - /// - /// Test element-wise for finiteness (not infinity or not Not a Number).

- /// - /// The result is returned as a boolean array.

- /// - /// Notes - /// - /// Not a Number, positive infinity and negative infinity are considered - /// to be non-finite.

- /// - /// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic - /// (IEEE 754).

- /// This means that Not a Number is not equivalent to infinity.

- /// - /// Also that positive infinity is not equivalent to negative infinity.

- /// But - /// infinity is equivalent to positive infinity.

- /// Errors result if the - /// second argument is also supplied when x is a scalar input, or if - /// first and second arguments have different shapes. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// True where x is not positive infinity, negative infinity, - /// or NaN; false otherwise.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray isfinite(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("isfinite", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Test element-wise for positive or negative infinity.

- /// - /// Returns a boolean array of the same shape as x, True where x == - /// +/-inf, otherwise False.

- /// - /// Notes - /// - /// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic - /// (IEEE 754).

- /// - /// Errors result if the second argument is supplied when the first - /// argument is a scalar, or if the first and second arguments have - /// different shapes. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// True where x is positive or negative infinity, false otherwise.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray isinf(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("isinf", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Test element-wise for NaN and return result as a boolean array.

- /// - /// Notes - /// - /// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic - /// (IEEE 754).

- /// This means that Not a Number is not equivalent to infinity. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// True where x is NaN, false otherwise.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray isnan(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("isnan", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Test element-wise for NaT (not a time) and return result as a boolean array. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// True where x is NaT, false otherwise.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray isnat(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("isnat", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Test element-wise for negative infinity, return result as bool array.

- /// - /// Notes - /// - /// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic - /// (IEEE 754).

- /// - /// Errors result if the second argument is also supplied when x is a scalar - /// input, if first and second arguments have different shapes, or if the - /// first argument has complex values. - /// - /// - /// A boolean array with the same shape and type as x to store the - /// result. - /// - /// - /// A boolean array with the same dimensions as the input.

- /// - /// If second argument is not supplied then a numpy boolean array is - /// returned with values True where the corresponding element of the - /// input is negative infinity and values False where the element of - /// the input is not negative infinity.

- /// - /// If a second argument is supplied the result is stored there.

- /// If the - /// type of that array is a numeric type the result is represented as - /// zeros and ones, if the type is boolean then as False and True.

- /// The - /// return value out is then a reference to that array. - /// - public NDarray isneginf(NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("isneginf", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Test element-wise for positive infinity, return result as bool array.

- /// - /// Notes - /// - /// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic - /// (IEEE 754).

- /// - /// Errors result if the second argument is also supplied when x is a scalar - /// input, if first and second arguments have different shapes, or if the - /// first argument has complex values - /// - /// - /// A boolean array with the same shape as x to store the result. - /// - /// - /// A boolean array with the same dimensions as the input.

- /// - /// If second argument is not supplied then a boolean array is returned - /// with values True where the corresponding element of the input is - /// positive infinity and values False where the element of the input is - /// not positive infinity.

- /// - /// If a second argument is supplied the result is stored there.

- /// If the - /// type of that array is a numeric type the result is represented as zeros - /// and ones, if the type is boolean then as False and True.

- /// - /// The return value out is then a reference to that array. - /// - public NDarray isposinf(NDarray y = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (y!=null) kwargs["y"]=ToPython(y); - dynamic py = __self__.InvokeMethod("isposinf", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns a bool array, where True if input element is complex.

- /// - /// What is tested is whether the input has a non-zero imaginary part, not if - /// the input type is complex. - /// - /// - /// Output array. - /// - public NDarray iscomplex() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("iscomplex"); - return ToCsharp(py); - } - - /// - /// Returns True if the array is Fortran contiguous but not C contiguous.

- /// - /// This function is obsolete and, because of changes due to relaxed stride - /// checking, its return value for the same array may differ for versions - /// of NumPy >= 1.10.0 and previous versions.

- /// If you only want to check if an - /// array is Fortran contiguous use a.flags.f_contiguous instead. - /// - public bool isfortran() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("isfortran"); - return ToCsharp(py); - } - - /// - /// Returns a bool array, where True if input element is real.

- /// - /// If element has complex type with zero complex part, the return value - /// for that element is True. - /// - /// - /// Boolean array of same shape as x. - /// - public NDarray isreal() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("isreal"); - return ToCsharp(py); - } - - /// - /// Compute the truth value of x1 AND x2 element-wise. - /// - /// - /// Input arrays.

- /// x1 and x2 must be of the same shape. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Boolean result with the same shape as x1 and x2 of the logical - /// AND operation on corresponding elements of x1 and x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray logical_and(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("logical_and", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the truth value of x1 OR x2 element-wise. - /// - /// - /// Logical OR is applied to the elements of x1 and x2. - /// They have to be of the same shape. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Boolean result with the same shape as x1 and x2 of the logical - /// OR operation on elements of x1 and x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray logical_or(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("logical_or", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the truth value of NOT x element-wise. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Boolean result with the same shape as x of the NOT operation - /// on elements of x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray logical_not(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("logical_not", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the truth value of x1 XOR x2, element-wise. - /// - /// - /// Logical XOR is applied to the elements of x1 and x2. They must - /// be broadcastable to the same shape. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Boolean result of the logical XOR operation applied to the elements - /// of x1 and x2; the shape is determined by whether or not - /// broadcasting of one or both arrays was required.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray logical_xor(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("logical_xor", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Returns True if two arrays are element-wise equal within a tolerance.

- /// - /// The tolerance values are positive, typically very small numbers.

- /// The - /// relative difference (rtol * abs(b)) and the absolute difference - /// atol are added together to compare against the absolute difference - /// between a and b.

- /// - /// If either array contains one or more NaNs, False is returned.

- /// - /// Infs are treated as equal if they are in the same place and of the same - /// sign in both arrays.

- /// - /// Notes - /// - /// If the following equation is element-wise True, then allclose returns - /// True.

- /// - /// The above equation is not symmetric in a and b, so that - /// allclose(a, b) might be different from allclose(b, a) in - /// some rare cases.

- /// - /// The comparison of a and b uses standard broadcasting, which - /// means that a and b need not have the same shape in order for - /// allclose(a, b) to evaluate to True.

- /// The same is true for - /// equal but not array_equal. - /// - /// - /// Input arrays to compare. - /// - /// - /// The relative tolerance parameter (see Notes). - /// - /// - /// The absolute tolerance parameter (see Notes). - /// - /// - /// Whether to compare NaN’s as equal.

- /// If True, NaN’s in a will be - /// considered equal to NaN’s in b in the output array. - /// - /// - /// Returns True if the two arrays are equal within the given - /// tolerance; False otherwise. - /// - public bool allclose(NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a, - }); - var kwargs=new PyDict(); - if (rtol!=1e-05f) kwargs["rtol"]=ToPython(rtol); - if (atol!=1e-08f) kwargs["atol"]=ToPython(atol); - if (equal_nan!=false) kwargs["equal_nan"]=ToPython(equal_nan); - dynamic py = __self__.InvokeMethod("allclose", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns a boolean array where two arrays are element-wise equal within a - /// tolerance.

- /// - /// The tolerance values are positive, typically very small numbers.

- /// The - /// relative difference (rtol * abs(b)) and the absolute difference - /// atol are added together to compare against the absolute difference - /// between a and b.

- /// - /// Notes - /// - /// For finite values, isclose uses the following equation to test whether - /// two floating point values are equivalent.

- /// - /// Unlike the built-in math.isclose, the above equation is not symmetric - /// in a and b – it assumes b is the reference value – so that - /// isclose(a, b) might be different from isclose(b, a).

- /// Furthermore, - /// the default value of atol is not zero, and is used to determine what - /// small values should be considered close to zero.

- /// The default value is - /// appropriate for expected values of order unity: if the expected values - /// are significantly smaller than one, it can result in false positives.

- /// - /// atol should be carefully selected for the use case at hand.

- /// A zero value - /// for atol will result in False if either a or b is zero. - /// - /// - /// Input arrays to compare. - /// - /// - /// The relative tolerance parameter (see Notes). - /// - /// - /// The absolute tolerance parameter (see Notes). - /// - /// - /// Whether to compare NaN’s as equal.

- /// If True, NaN’s in a will be - /// considered equal to NaN’s in b in the output array. - /// - /// - /// Returns a boolean array of where a and b are equal within the - /// given tolerance.

- /// If both a and b are scalars, returns a single - /// boolean value. - /// - public NDarray isclose(NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a, - }); - var kwargs=new PyDict(); - if (rtol!=1e-05f) kwargs["rtol"]=ToPython(rtol); - if (atol!=1e-08f) kwargs["atol"]=ToPython(atol); - if (equal_nan!=false) kwargs["equal_nan"]=ToPython(equal_nan); - dynamic py = __self__.InvokeMethod("isclose", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// True if two arrays have the same shape and elements, False otherwise. - /// - /// - /// Input arrays. - /// - /// - /// Returns True if the arrays are equal. - /// - public bool array_equal(NDarray a1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a1, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("array_equal", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns True if input arrays are shape consistent and all elements equal.

- /// - /// Shape consistent means they are either the same shape, or one input array - /// can be broadcasted to create the same shape as the other one. - /// - /// - /// Input arrays. - /// - /// - /// True if equivalent, False otherwise. - /// - public bool array_equiv(NDarray a1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a1, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("array_equiv", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the truth value of (x1 > x2) element-wise. - /// - /// - /// Input arrays.

- /// If x1.shape != x2.shape, they must be - /// broadcastable to a common shape (which may be the shape of one or - /// the other). - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array, element-wise comparison of x1 and x2. - /// Typically of type bool, unless dtype=object is passed.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray greater(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("greater", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the truth value of (x1 >= x2) element-wise. - /// - /// - /// Input arrays.

- /// If x1.shape != x2.shape, they must be - /// broadcastable to a common shape (which may be the shape of one or - /// the other). - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array, element-wise comparison of x1 and x2. - /// Typically of type bool, unless dtype=object is passed.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray greater_equal(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("greater_equal", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Return the truth value of (x1 < x2) element-wise. - /// - /// - /// Input arrays.

- /// If x1.shape != x2.shape, they must be - /// broadcastable to a common shape (which may be the shape of one or - /// the other). - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array, element-wise comparison of x1 and x2. - /// Typically of type bool, unless dtype=object is passed.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray less(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("less", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the truth value of (x1 =< x2) element-wise. - /// - /// - /// Input arrays.

- /// If x1.shape != x2.shape, they must be - /// broadcastable to a common shape (which may be the shape of one or - /// the other). - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array, element-wise comparison of x1 and x2. - /// Typically of type bool, unless dtype=object is passed.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray less_equal(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("less_equal", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return (x1 == x2) element-wise. - /// - /// - /// Input arrays of the same shape. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array, element-wise comparison of x1 and x2. - /// Typically of type bool, unless dtype=object is passed.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray equal(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("equal", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return (x1 != x2) element-wise. - /// - /// - /// Input arrays. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array, element-wise comparison of x1 and x2. - /// Typically of type bool, unless dtype=object is passed.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray not_equal(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("not_equal", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Trigonometric sine, element-wise.

- /// - /// 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 axis, makes - /// an angle at the origin (measured counter-clockwise from that axis), and - /// departs from the origin.

- /// The coordinate of the outgoing - /// ray’s intersection with the unit circle is the sine of that angle.

- /// It - /// ranges from -1 for to +1 for The - /// function has zeroes where the angle is a multiple of . - /// Sines of angles between and are negative.

- /// - /// The numerous properties of the sine and related functions are included - /// in any standard trigonometry text. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The sine of each element of x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray sin(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("sin", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Cosine element-wise.

- /// - /// 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. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The corresponding cosine values.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray cos(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("cos", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute tangent element-wise.

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

- /// - /// 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. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The corresponding tangent values.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray tan(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("tan", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Inverse sine, element-wise.

- /// - /// Notes - /// - /// arcsin is a multivalued function: for each x there are infinitely - /// many numbers z such that . The convention is to - /// return the angle z whose real part lies in [-pi/2, pi/2].

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

- /// - /// http://www.math.sfu.ca/~cbm/aands/ - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// 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. - /// - public NDarray arcsin(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("arcsin", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Trigonometric inverse cosine, element-wise.

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

- /// - /// 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. http://www.math.sfu.ca/~cbm/aands/ - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// 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. - /// - public NDarray arccos(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("arccos", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Trigonometric inverse tangent, element-wise.

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

- /// - /// 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. - /// http://www.math.sfu.ca/~cbm/aands/ - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// 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. - /// - public NDarray arctan(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("arctan", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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) - /// - /// - /// Leg of the triangle(s). - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The hypotenuse of the triangle(s).

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray hypot(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("hypot", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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.

- /// - /// Notes - /// - /// arctan2 is identical to the atan2 function of the underlying - /// C library.

- /// The following special values are defined in the C - /// standard: [1] - /// - /// Note that +0 and -0 are distinct floating point numbers, as are +inf - /// and -inf.

- /// - /// References - /// - /// - /// x-coordinates.

- /// x2 must be broadcastable to match the shape of - /// x1 or vice versa. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Array of angles in radians, in the range [-pi, pi].

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray arctan2(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("arctan2", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Convert angles from radians to degrees. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The corresponding degree values; if out was supplied this is a - /// reference to it.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray degrees(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("degrees", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Convert angles from degrees to radians. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The corresponding radian values.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray radians(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("radians", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Unwrap by changing deltas between values to 2*pi complement.

- /// - /// Unwrap radian phase p by changing absolute jumps greater than - /// discont to their 2*pi complement along the given axis.

- /// - /// Notes - /// - /// If the discontinuity in p is smaller than pi, but larger than - /// discont, no unwrapping is done because taking the 2*pi complement - /// would only make the discontinuity larger. - /// - /// - /// Maximum discontinuity between values, default is pi. - /// - /// - /// Axis along which unwrap will operate, default is the last axis. - /// - /// - /// Output array. - /// - public NDarray unwrap(float? discont = 3.141592653589793f, int? axis = -1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (discont!=3.141592653589793f) kwargs["discont"]=ToPython(discont); - if (axis!=-1) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("unwrap", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Convert angles from degrees to radians.

- /// - /// Notes - /// - /// deg2rad(x) is x * pi / 180. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The corresponding angle in radians.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray deg2rad(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("deg2rad", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Convert angles from radians to degrees.

- /// - /// Notes - /// - /// rad2deg(x) is 180 * x / pi. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The corresponding angle in degrees.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray rad2deg(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("rad2deg", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Hyperbolic sine, element-wise.

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

- /// - /// 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. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The corresponding hyperbolic sine values.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray sinh(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("sinh", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Hyperbolic cosine, element-wise.

- /// - /// Equivalent to 1/2 * (np.exp(x) + np.exp(-x)) and np.cos(1j*x). - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array of same shape as x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray cosh(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("cosh", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute hyperbolic tangent element-wise.

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

- /// - /// Notes - /// - /// If out is provided, the function writes the result into it, - /// and returns a reference to out.

- /// (See Examples) - /// - /// References - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The corresponding hyperbolic tangent values.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray tanh(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("tanh", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Inverse hyperbolic sine element-wise.

- /// - /// 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 - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Array of the same shape as x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray arcsinh(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("arcsinh", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Inverse hyperbolic cosine, element-wise.

- /// - /// 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 - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Array of the same shape as x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray arccosh(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("arccosh", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Inverse hyperbolic tangent element-wise.

- /// - /// 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 - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Array of the same shape as x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray arctanh(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("arctanh", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Evenly round to the given number of decimals.

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

- /// Results may also be surprising due - /// to the inexact representation of decimal fractions in the IEEE - /// floating point standard [1] and errors introduced when scaling - /// by powers of ten.

- /// - /// References - /// - /// - /// Number of decimal places to round to (default: 0).

- /// If - /// decimals is negative, it specifies the number of positions to - /// the left of the decimal point. - /// - /// - /// Alternative output array in which to place the result.

- /// It must have - /// the same shape as the expected output, but the type of the output - /// values will be cast if necessary.

- /// See doc.ufuncs (Section - /// “Output arguments”) for details. - /// - /// - /// An array of the same type as a, containing the rounded values.

- /// - /// Unless out was specified, a new array is created.

- /// A reference to - /// the result is returned.

- /// - /// The real and imaginary parts of complex numbers are rounded - /// separately.

- /// The result of rounding a float is a float. - /// - public NDarray around(int? decimals = 0, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (decimals!=0) kwargs["decimals"]=ToPython(decimals); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("around", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Round elements of the array to the nearest integer. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array is same shape and type as x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray rint(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("rint", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Round to nearest integer towards zero.

- /// - /// Round an array of floats element-wise to nearest integer towards zero.

- /// - /// The rounded values are returned as floats. - /// - /// - /// Output array - /// - /// - /// The array of rounded numbers - /// - public NDarray fix(NDarray y = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (y!=null) kwargs["y"]=ToPython(y); - dynamic py = __self__.InvokeMethod("fix", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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 . - /// - /// Notes - /// - /// Some spreadsheet programs calculate the “floor-towards-zero”, in other - /// words floor(-2.5) == -2. NumPy instead uses the definition of - /// floor where floor(-2.5) == -3. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The floor of each element in x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray floor(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("floor", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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 . - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The ceiling of each element in x, with float dtype.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray ceil(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("ceil", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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.

- /// - /// Notes - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The truncated value of each element in x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray trunc(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("trunc", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the product of array elements over a given axis.

- /// - /// Notes - /// - /// Arithmetic is modular when using integer types, and no error is - /// raised on overflow.

- /// That means that, on a 32-bit platform: - /// - /// The product of an empty array is the neutral element 1: - /// - /// - /// Axis or axes along which a product is performed.

- /// The default, - /// axis=None, will calculate the product of all the elements in the - /// input array.

- /// If axis is negative it counts from the last to the - /// first axis.

- /// - /// If axis is a tuple of ints, a product is performed on all of the - /// axes specified in the tuple instead of a single axis or all the - /// axes as before. - /// - /// - /// The type of the returned array, as well as of the accumulator in - /// which the elements are multiplied.

- /// The dtype of a is used by - /// default unless a has an integer dtype of less precision than the - /// default platform integer.

- /// In that case, if a is signed then the - /// platform integer is used while if a is unsigned then an unsigned - /// integer of the same precision as the platform integer is used. - /// - /// - /// Alternative output array in which to place the result.

- /// It must have - /// the same shape as the expected output, but the type of the output - /// values will be cast if necessary. - /// - /// - /// If this is set to True, the axes which are reduced are left in the - /// result as dimensions with size one.

- /// With this option, the result - /// will broadcast correctly against the input array.

- /// - /// If the default value is passed, then keepdims will not be - /// passed through to the prod method of sub-classes of - /// ndarray, however any non-default value will be.

- /// If the - /// sub-class’ method does not implement keepdims any - /// exceptions will be raised. - /// - /// - /// The starting value for this product.

- /// See reduce for details. - /// - /// - /// An array shaped as a but with the specified axis removed.

- /// - /// Returns a reference to out if specified. - /// - public NDarray prod(Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - if (initial!=null) kwargs["initial"]=ToPython(initial); - dynamic py = __self__.InvokeMethod("prod", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Sum of array elements over a given axis.

- /// - /// Notes - /// - /// Arithmetic is modular when using integer types, and no error is - /// raised on overflow.

- /// - /// The sum of an empty array is the neutral element 0: - /// - /// - /// Axis or axes along which a sum is performed.

- /// The default, - /// axis=None, will sum all of the elements of the input array.

- /// If - /// axis is negative it counts from the last to the first axis.

- /// - /// If axis is a tuple of ints, a sum is performed on all of the axes - /// specified in the tuple instead of a single axis or all the axes as - /// before. - /// - /// - /// The type of the returned array and of the accumulator in which the - /// elements are summed.

- /// The dtype of a is used by default unless a - /// has an integer dtype of less precision than the default platform - /// integer.

- /// In that case, if a is signed then the platform integer - /// is used while if a is unsigned then an unsigned integer of the - /// same precision as the platform integer is used. - /// - /// - /// Alternative output array in which to place the result.

- /// It must have - /// the same shape as the expected output, but the type of the output - /// values will be cast if necessary. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the input array.

- /// - /// If the default value is passed, then keepdims will not be - /// passed through to the sum method of sub-classes of - /// ndarray, however any non-default value will be.

- /// If the - /// sub-class’ method does not implement keepdims any - /// exceptions will be raised. - /// - /// - /// Starting value for the sum.

- /// See reduce for details. - /// - /// - /// An array with the same shape as a, with the specified - /// axis removed.

- /// If a is a 0-d array, or if axis is None, a scalar - /// is returned.

- /// If an output array is specified, a reference to - /// out is returned. - /// - public NDarray sum(Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - if (initial!=null) kwargs["initial"]=ToPython(initial); - dynamic py = __self__.InvokeMethod("sum", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the product of array elements over a given axis treating Not a - /// Numbers (NaNs) as ones.

- /// - /// One is returned for slices that are all-NaN or empty. - /// - /// - /// Axis or axes along which the product is computed.

- /// The default is to compute - /// the product of the flattened array. - /// - /// - /// The type of the returned array and of the accumulator in which the - /// elements are summed.

- /// By default, the dtype of a is used.

- /// An - /// exception is when a has an integer type with less precision than - /// the platform (u)intp.

- /// In that case, the default will be either - /// (u)int32 or (u)int64 depending on whether the platform is 32 or 64 - /// bits.

- /// For inexact inputs, dtype must be inexact. - /// - /// - /// Alternate output array in which to place the result.

- /// The default - /// is None.

- /// If provided, it must have the same shape as the - /// expected output, but the type will be cast if necessary.

- /// See - /// doc.ufuncs for details.

- /// The casting of NaN to integer can yield - /// unexpected results. - /// - /// - /// If True, the axes which are reduced are left in the result as - /// dimensions with size one.

- /// With this option, the result will - /// broadcast correctly against the original arr. - /// - /// - /// A new array holding the result is returned unless out is - /// specified, in which case it is returned. - /// - public NDarray nanprod(Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanprod", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the sum of array elements over a given axis treating Not a - /// Numbers (NaNs) as zero.

- /// - /// In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or - /// empty.

- /// In later versions zero is returned.

- /// - /// Notes - /// - /// If both positive and negative infinity are present, the sum will be Not - /// A Number (NaN). - /// - /// - /// Axis or axes along which the sum is computed.

- /// The default is to compute the - /// sum of the flattened array. - /// - /// - /// The type of the returned array and of the accumulator in which the - /// elements are summed.

- /// By default, the dtype of a is used.

- /// An - /// exception is when a has an integer type with less precision than - /// the platform (u)intp.

- /// In that case, the default will be either - /// (u)int32 or (u)int64 depending on whether the platform is 32 or 64 - /// bits.

- /// For inexact inputs, dtype must be inexact. - /// - /// - /// Alternate output array in which to place the result.

- /// The default - /// is None.

- /// If provided, it must have the same shape as the - /// expected output, but the type will be cast if necessary.

- /// See - /// doc.ufuncs for details.

- /// The casting of NaN to integer can yield - /// unexpected results. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the original a.

- /// - /// If the value is anything but the default, then - /// keepdims will be passed through to the mean or sum methods - /// of sub-classes of ndarray.

- /// If the sub-classes methods - /// does not implement keepdims any exceptions will be raised. - /// - /// - /// A new array holding the result is returned unless out is - /// specified, in which it is returned.

- /// The result has the same - /// size as a, and the same shape as a if axis is not None - /// or a is a 1-d array. - /// - public NDarray nansum(Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nansum", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the cumulative product of elements along a given axis.

- /// - /// Notes - /// - /// Arithmetic is modular when using integer types, and no error is - /// raised on overflow. - /// - /// - /// Axis along which the cumulative product is computed.

- /// By default - /// the input is flattened. - /// - /// - /// Type of the returned array, as well as of the accumulator in which - /// the elements are multiplied.

- /// If dtype is not specified, it - /// defaults to the dtype of a, unless a has an integer dtype with - /// a precision less than that of the default platform integer.

- /// In - /// that case, the default platform integer is used instead. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output - /// but the type of the resulting values will be cast if necessary. - /// - /// - /// A new array holding the result is returned unless out is - /// specified, in which case a reference to out is returned. - /// - public NDarray cumprod(int? axis = null, Dtype dtype = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("cumprod", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the cumulative sum of the elements along a given axis.

- /// - /// Notes - /// - /// Arithmetic is modular when using integer types, and no error is - /// raised on overflow. - /// - /// - /// Axis along which the cumulative sum is computed.

- /// The default - /// (None) is to compute the cumsum over the flattened array. - /// - /// - /// Type of the returned array and of the accumulator in which the - /// elements are summed.

- /// If dtype is not specified, it defaults - /// to the dtype of a, unless a has an integer dtype with a - /// precision less than that of the default platform integer.

- /// In - /// that case, the default platform integer is used. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output - /// but the type will be cast if necessary.

- /// See doc.ufuncs - /// (Section “Output arguments”) for more details. - /// - /// - /// A new array holding the result is returned unless out is - /// specified, in which case a reference to out is returned.

- /// The - /// result has the same size as a, and the same shape as a if - /// axis is not None or a is a 1-d array. - /// - public NDarray cumsum(int? axis = null, Dtype dtype = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("cumsum", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the cumulative product of array elements over a given axis treating Not a - /// Numbers (NaNs) as one.

- /// The cumulative product does not change when NaNs are - /// encountered and leading NaNs are replaced by ones.

- /// - /// Ones are returned for slices that are all-NaN or empty. - /// - /// - /// Axis along which the cumulative product is computed.

- /// By default - /// the input is flattened. - /// - /// - /// Type of the returned array, as well as of the accumulator in which - /// the elements are multiplied.

- /// If dtype is not specified, it - /// defaults to the dtype of a, unless a has an integer dtype with - /// a precision less than that of the default platform integer.

- /// In - /// that case, the default platform integer is used instead. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output - /// but the type of the resulting values will be cast if necessary. - /// - /// - /// A new array holding the result is returned unless out is - /// specified, in which case it is returned. - /// - public NDarray nancumprod(int? axis = null, Dtype dtype = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("nancumprod", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the cumulative sum of array elements over a given axis treating Not a - /// Numbers (NaNs) as zero.

- /// The cumulative sum does not change when NaNs are - /// encountered and leading NaNs are replaced by zeros.

- /// - /// Zeros are returned for slices that are all-NaN or empty. - /// - /// - /// Axis along which the cumulative sum is computed.

- /// The default - /// (None) is to compute the cumsum over the flattened array. - /// - /// - /// Type of the returned array and of the accumulator in which the - /// elements are summed.

- /// If dtype is not specified, it defaults - /// to the dtype of a, unless a has an integer dtype with a - /// precision less than that of the default platform integer.

- /// In - /// that case, the default platform integer is used. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output - /// but the type will be cast if necessary.

- /// See doc.ufuncs - /// (Section “Output arguments”) for more details. - /// - /// - /// A new array holding the result is returned unless out is - /// specified, in which it is returned.

- /// The result has the same - /// size as a, and the same shape as a if axis is not None - /// or a is a 1-d array. - /// - public NDarray nancumsum(int? axis = null, Dtype dtype = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("nancumsum", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Calculate the n-th discrete difference along the given axis.

- /// - /// The first difference is given by out[n] = a[n+1] - a[n] along - /// the given axis, higher differences are calculated by using diff - /// recursively.

- /// - /// Notes - /// - /// Type is preserved for boolean arrays, so the result will contain - /// False when consecutive elements are the same and True when they - /// differ.

- /// - /// For unsigned integer arrays, the results will also be unsigned.

- /// This - /// should not be surprising, as the result is consistent with - /// calculating the difference directly: - /// - /// If this is not desirable, then the array should be cast to a larger - /// integer type first: - /// - /// - /// The number of times values are differenced.

- /// If zero, the input - /// is returned as-is. - /// - /// - /// The axis along which the difference is taken, default is the - /// last axis. - /// - /// - /// Values to prepend or append to “a” along axis prior to - /// performing the difference.

- /// Scalar values are expanded to - /// arrays with length 1 in the direction of axis and the shape - /// of the input array in along all other axes.

- /// Otherwise the - /// dimension and shape must match “a” except along axis. - /// - /// - /// Values to prepend or append to “a” along axis prior to - /// performing the difference.

- /// Scalar values are expanded to - /// arrays with length 1 in the direction of axis and the shape - /// of the input array in along all other axes.

- /// Otherwise the - /// dimension and shape must match “a” except along axis. - /// - /// - /// The n-th differences.

- /// The shape of the output is the same as a - /// except along axis where the dimension is smaller by n.

- /// The - /// type of the output is the same as the type of the difference - /// between any two elements of a.

- /// This is the same as the type of - /// a in most cases.

- /// A notable exception is datetime64, which - /// results in a timedelta64 output array. - /// - public NDarray diff(int? n = 1, int? axis = -1, NDarray append = null, NDarray prepend = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (n!=1) kwargs["n"]=ToPython(n); - if (axis!=-1) kwargs["axis"]=ToPython(axis); - if (append!=null) kwargs["append"]=ToPython(append); - if (prepend!=null) kwargs["prepend"]=ToPython(prepend); - dynamic py = __self__.InvokeMethod("diff", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// The differences between consecutive elements of an array.

- /// - /// Notes - /// - /// When applied to masked arrays, this function drops the mask information - /// if the to_begin and/or to_end parameters are used. - /// - /// - /// Number(s) to append at the end of the returned differences. - /// - /// - /// Number(s) to prepend at the beginning of the returned differences. - /// - /// - /// The differences.

- /// Loosely, this is ary.flat[1:] - ary.flat[:-1]. - /// - public NDarray ediff1d(NDarray to_end = null, NDarray to_begin = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (to_end!=null) kwargs["to_end"]=ToPython(to_end); - if (to_begin!=null) kwargs["to_begin"]=ToPython(to_begin); - dynamic py = __self__.InvokeMethod("ediff1d", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the gradient of an N-dimensional array.

- /// - /// The gradient is computed using second order accurate central differences - /// in the interior points and either first or second order accurate one-sides - /// (forward or backwards) differences at the boundaries.

- /// - /// The returned gradient hence has the same shape as the input array.

- /// - /// Notes - /// - /// Assuming that (i.e., has at least 3 continuous - /// derivatives) and let be a non-homogeneous stepsize, we - /// minimize the “consistency error” between the true gradient - /// and its estimate from a linear combination of the neighboring grid-points: - /// - /// By substituting and - /// with their Taylor series expansion, this translates into solving - /// the following the linear system: - /// - /// The resulting approximation of is the following: - /// - /// It is worth noting that if - /// (i.e., data are evenly spaced) - /// we find the standard second order approximation: - /// - /// With a similar procedure the forward/backward approximations used for - /// boundaries can be derived.

- /// - /// References - /// - /// - /// Spacing between f values.

- /// Default unitary spacing for all dimensions.

- /// - /// Spacing can be specified using: - /// - /// If axis is given, the number of varargs must equal the number of axes.

- /// - /// Default: 1. - /// - /// - /// Gradient is calculated using N-th order accurate differences - /// at the boundaries.

- /// Default: 1. - /// - /// - /// Gradient is calculated only along the given axis or axes - /// The default (axis = None) is to calculate the gradient for all the axes - /// of the input array.

- /// axis may be negative, in which case it counts from - /// the last to the first axis. - /// - /// - /// A set of ndarrays (or a single ndarray if there is only one dimension) - /// corresponding to the derivatives of f with respect to each dimension.

- /// - /// Each derivative has the same shape as f. - /// - public NDarray gradient(NDarray varargs = null, int? edge_order = null, Axis axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (varargs!=null) kwargs["varargs"]=ToPython(varargs); - if (edge_order!=null) kwargs["edge_order"]=ToPython(edge_order); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("gradient", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the cross product of two (arrays of) vectors.

- /// - /// The cross product of a and b in is a vector perpendicular - /// to both a and b.

- /// If a and b are arrays of vectors, the vectors - /// are defined by the last axis of a and b by default, and these axes - /// can have dimensions 2 or 3.

- /// Where the dimension of either a or b is - /// 2, the third component of the input vector is assumed to be zero and the - /// cross product calculated accordingly.

- /// In cases where both input vectors - /// have dimension 2, the z-component of the cross product is returned.

- /// - /// Notes - /// - /// Supports full broadcasting of the inputs. - /// - /// - /// Components of the second vector(s). - /// - /// - /// Axis of a that defines the vector(s).

- /// By default, the last axis. - /// - /// - /// Axis of b that defines the vector(s).

- /// By default, the last axis. - /// - /// - /// Axis of c containing the cross product vector(s).

- /// Ignored if - /// both input vectors have dimension 2, as the return is scalar.

- /// - /// By default, the last axis. - /// - /// - /// If defined, the axis of a, b and c that defines the vector(s) - /// and cross product(s).

- /// Overrides axisa, axisb and axisc. - /// - /// - /// Vector cross product(s). - /// - public NDarray cross(NDarray b, int? axisa = -1, int? axisb = -1, int? axisc = -1, int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - b, - }); - var kwargs=new PyDict(); - if (axisa!=-1) kwargs["axisa"]=ToPython(axisa); - if (axisb!=-1) kwargs["axisb"]=ToPython(axisb); - if (axisc!=-1) kwargs["axisc"]=ToPython(axisc); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("cross", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Integrate along the given axis using the composite trapezoidal rule.

- /// - /// Integrate y (x) along given axis.

- /// - /// Notes - /// - /// Image [2] illustrates trapezoidal rule – y-axis locations of points - /// will be taken from y array, by default x-axis distances between - /// points will be 1.0, alternatively they can be provided with x array - /// or with dx scalar.

- /// Return value will be equal to combined area under - /// the red lines.

- /// - /// References - /// - /// - /// The sample points corresponding to the y values.

- /// If x is None, - /// the sample points are assumed to be evenly spaced dx apart.

- /// The - /// default is None. - /// - /// - /// The spacing between sample points when x is None.

- /// The default is 1. - /// - /// - /// The axis along which to integrate. - /// - /// - /// Definite integral as approximated by trapezoidal rule. - /// - public float trapz(NDarray x = null, float? dx = 1.0f, int? axis = -1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (x!=null) kwargs["x"]=ToPython(x); - if (dx!=1.0f) kwargs["dx"]=ToPython(dx); - if (axis!=-1) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("trapz", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Calculate the exponential of all elements in the input 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 , - /// then . For real input, exp(x) is always positive.

- /// - /// For complex arguments, x = a + ib, we can write - /// . The first term, , is already - /// known (it is the real argument, described above).

- /// The second term, - /// , is , a function with - /// magnitude 1 and a periodic phase.

- /// - /// References - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array, element-wise exponential of x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray exp(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("exp", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Calculate exp(x) - 1 for all elements in the array.

- /// - /// Notes - /// - /// This function provides greater precision than exp(x) - 1 - /// for small values of x. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Element-wise exponential minus one: out = exp(x) - 1.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray expm1(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("expm1", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Calculate 2**p for all p in the input array.

- /// - /// Notes - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Element-wise 2 to the power x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray exp2(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("exp2", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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.

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

- /// - /// References - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The natural logarithm of x, element-wise.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray log(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("log", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the base 10 logarithm of the input array, element-wise.

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

- /// - /// References - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// 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. - /// - public NDarray log10(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("log10", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Base-2 logarithm of x.

- /// - /// Notes - /// - /// 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. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Base-2 logarithm of x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray log2(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("log2", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the natural logarithm of one plus the input array, element-wise.

- /// - /// Calculates log(1 + x).

- /// - /// 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 - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Natural logarithm of 1 + x, element-wise.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray log1p(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("log1p", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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.

- /// - /// Notes - /// - /// - /// Input values. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Logarithm of exp(x1) + exp(x2).

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray logaddexp(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("logaddexp", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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.

- /// - /// Notes - /// - /// - /// Input values. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Base-2 logarithm of 2**x1 + 2**x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray logaddexp2(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("logaddexp2", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the sinc function.

- /// - /// The sinc function is . - /// - /// Notes - /// - /// sinc(0) is the limit value 1.

- /// - /// The name sinc is short for “sine cardinal” or “sinus cardinalis”. - /// - /// The sinc function is used in various signal processing applications, - /// including in anti-aliasing, in the construction of a Lanczos resampling - /// filter, and in interpolation.

- /// - /// For bandlimited interpolation of discrete-time signals, the ideal - /// interpolation kernel is proportional to the sinc function.

- /// - /// References - /// - /// - /// sinc(x), which has the same shape as the input. - /// - public NDarray sinc() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("sinc"); - return ToCsharp(py); - } - - /// - /// Returns element-wise True where signbit is set (less than zero). - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Output array, or reference to out if that was supplied.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray signbit(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("signbit", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Change the sign of x1 to that of x2, element-wise.

- /// - /// If both arguments are arrays or sequences, they have to be of the same - /// length.

- /// If x2 is a scalar, its sign will be copied to all elements of - /// x1. - /// - /// - /// The sign of x2 is copied to x1. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The values of x1 with the sign of x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray copysign(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("copysign", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Decompose the elements of x into mantissa and twos exponent.

- /// - /// Returns (mantissa, exponent), where x = mantissa * 2**exponent`. - /// The mantissa is lies in the open interval(-1, 1), while the twos - /// exponent is a signed integer.

- /// - /// Notes - /// - /// Complex dtypes are not supported, they will raise a TypeError. - /// - /// - /// Output array for the mantissa.

- /// Must have the same shape as x. - /// - /// - /// Output array for the exponent.

- /// Must have the same shape as x. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// A tuple of: - /// mantissa - /// Floating values between -1 and 1. - /// This is a scalar if x is a scalar. - /// exponent - /// Integer exponents of 2. - /// This is a scalar if x is a scalar. - /// - public (NDarray, NDarray) frexp(NDarray out1 = null, NDarray out2 = null, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (out1!=null) kwargs["out1"]=ToPython(out1); - if (out2!=null) kwargs["out2"]=ToPython(out2); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("frexp", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Returns x1 * 2**x2, element-wise.

- /// - /// The mantissas x1 and twos exponents x2 are used to construct - /// floating point numbers x1 * 2**x2. - /// - /// 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. - /// - /// - /// Array of twos exponents. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The result of x1 * 2**x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray ldexp(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("ldexp", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the next floating-point value after x1 towards x2, element-wise. - /// - /// - /// The direction where to look for the next representable value of x1. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The next representable values of x1 in the direction of x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray nextafter(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("nextafter", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the distance between x and the nearest adjacent number.

- /// - /// 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. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The spacing of values of x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray spacing(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("spacing", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns the lowest common multiple of |x1| and |x2| - /// - /// - /// Arrays of values - /// - /// - /// The lowest common multiple of the absolute value of the inputs - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray lcm(NDarray x1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("lcm", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns the greatest common divisor of |x1| and |x2| - /// - /// - /// Arrays of values - /// - /// - /// The greatest common divisor of the absolute value of the inputs - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray gcd(NDarray x1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("gcd", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Add arguments element-wise.

- /// - /// Notes - /// - /// Equivalent to x1 + x2 in terms of array broadcasting. - /// - /// - /// The arrays to be added.

- /// If x1.shape != x2.shape, they must be - /// broadcastable to a common shape (which may be the shape of one or - /// the other). - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The sum of x1 and x2, element-wise.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray @add(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("add", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the reciprocal of the argument, element-wise.

- /// - /// Calculates 1/x.

- /// - /// Notes - /// - /// 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. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Return array.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray reciprocal(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("reciprocal", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Numerical positive, element-wise.

- /// - /// Notes - /// - /// Equivalent to x.copy(), but only defined for types that support - /// arithmetic. - /// - /// - /// Returned array or scalar: y = +x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray positive() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("positive"); - return ToCsharp(py); - } - - /// - /// Numerical negative, element-wise. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Returned array or scalar: y = -x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray negative(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("negative", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Multiply arguments element-wise.

- /// - /// Notes - /// - /// Equivalent to x1 * x2 in terms of array broadcasting. - /// - /// - /// Input arrays to be multiplied. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The product of x1 and x2, element-wise.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray multiply(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("multiply", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns a true division of the inputs, element-wise.

- /// - /// Instead of the Python traditional ‘floor division’, this returns a true - /// division.

- /// True division adjusts the output type to present the best - /// answer, regardless of input types.

- /// - /// Notes - /// - /// The floor division operator // was added in Python 2.2 making - /// // and / equivalent operators.

- /// The default floor division - /// operation of / can be replaced by true division with from - /// __future__ import division.

- /// - /// In Python 3.0, // is the floor division operator and / the - /// true division operator.

- /// The true_divide(x1, x2) function is - /// equivalent to true division in Python. - /// - /// - /// Divisor array. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray divide(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("divide", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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.

- /// Note that an - /// integer type raised to a negative integer power will raise a ValueError. - /// - /// - /// The exponents. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The bases in x1 raised to the exponents in x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray power(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("power", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Subtract arguments, element-wise.

- /// - /// Notes - /// - /// Equivalent to x1 - x2 in terms of array broadcasting. - /// - /// - /// The arrays to be subtracted from each other. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The difference of x1 and x2, element-wise.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray subtract(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("subtract", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns a true division of the inputs, element-wise.

- /// - /// Instead of the Python traditional ‘floor division’, this returns a true - /// division.

- /// True division adjusts the output type to present the best - /// answer, regardless of input types.

- /// - /// Notes - /// - /// The floor division operator // was added in Python 2.2 making - /// // and / equivalent operators.

- /// The default floor division - /// operation of / can be replaced by true division with from - /// __future__ import division.

- /// - /// In Python 3.0, // is the floor division operator and / the - /// true division operator.

- /// The true_divide(x1, x2) function is - /// equivalent to true division in Python. - /// - /// - /// Divisor array. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray true_divide(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("true_divide", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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 b = a % b + b * (a // b) - /// up to roundoff. - /// - /// - /// Denominator. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// y = floor(x1/x2) - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray floor_divide(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("floor_divide", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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. - /// - /// - /// The exponents. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The bases in x1 raised to the exponents in x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray float_power(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("float_power", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return 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. - /// - /// 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. - /// - /// - /// Divisor. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The remainder of the division of x1 by x2. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray fmod(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("fmod", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return 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.

- /// - /// Notes - /// - /// Returns 0 when x2 is 0 and both x1 and x2 are (arrays of) - /// integers. - /// - /// - /// Divisor array. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The element-wise remainder of the quotient floor_divide(x1, x2).

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray mod(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("mod", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the fractional and integral parts of an array, element-wise.

- /// - /// The fractional and integral parts are negative if the given number is - /// negative.

- /// - /// Notes - /// - /// For integer input the return values are floats. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// A tuple of: - /// y1 - /// Fractional part of x. - /// This is a scalar if x is a scalar. - /// y2 - /// Integral part of x. - /// This is a scalar if x is a scalar. - /// - public (NDarray, NDarray) modf(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("modf", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Return 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.

- /// - /// Notes - /// - /// Returns 0 when x2 is 0 and both x1 and x2 are (arrays of) - /// integers. - /// - /// - /// Divisor array. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The element-wise remainder of the quotient floor_divide(x1, x2).

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray remainder(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("remainder", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return element-wise quotient and remainder simultaneously.

- /// - /// 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. - /// - /// - /// Divisor array. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// A tuple of: - /// out1 - /// Element-wise quotient resulting from floor division. - /// This is a scalar if both x1 and x2 are scalars. - /// out2 - /// Element-wise remainder from floor division. - /// This is a scalar if both x1 and x2 are scalars. - /// - public (NDarray, NDarray) divmod(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("divmod", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Return the angle of the complex argument. - /// - /// - /// Return angle in degrees if True, radians if False (default). - /// - /// - /// The counterclockwise angle from the positive real axis on - /// the complex plane, with dtype as numpy.float64. - /// - public NDarray angle(bool? deg = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (deg!=false) kwargs["deg"]=ToPython(deg); - dynamic py = __self__.InvokeMethod("angle", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the complex conjugate, element-wise.

- /// - /// The complex conjugate of a complex number is obtained by changing the - /// sign of its imaginary part. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The complex conjugate of x, with same dtype as y.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray conj(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("conj", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns the discrete, linear convolution of two one-dimensional sequences.

- /// - /// The convolution operator is often seen in signal processing, where it - /// models the effect of a linear time-invariant system on a signal [1].

- /// In - /// probability theory, the sum of two independent random variables is - /// distributed according to the convolution of their individual - /// distributions.

- /// - /// If v is longer than a, the arrays are swapped before computation.

- /// - /// Notes - /// - /// The discrete convolution operation is defined as - /// - /// It can be shown that a convolution in time/space - /// is equivalent to the multiplication in the Fourier - /// domain, after appropriate padding (padding is necessary to prevent - /// circular convolution).

- /// Since multiplication is more efficient (faster) - /// than convolution, the function scipy.signal.fftconvolve exploits the - /// FFT to calculate the convolution of large data-sets.

- /// - /// References - /// - /// - /// Second one-dimensional input array. - /// - /// - /// Discrete, linear convolution of a and v. - /// - public NDarray convolve(NDarray v, string mode = "full") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - v, - }); - var kwargs=new PyDict(); - if (mode!="full") kwargs["mode"]=ToPython(mode); - dynamic py = __self__.InvokeMethod("convolve", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Clip (limit) the values in an array.

- /// - /// Given an interval, values outside the interval are clipped to - /// the interval edges.

- /// For example, if an interval of [0, 1] - /// is specified, values smaller than 0 become 0, and values larger - /// than 1 become 1. - /// - /// - /// Minimum value.

- /// If None, clipping is not performed on lower - /// interval edge.

- /// Not more than one of a_min and a_max may be - /// None. - /// - /// - /// Maximum value.

- /// If None, clipping is not performed on upper - /// interval edge.

- /// Not more than one of a_min and a_max may be - /// None.

- /// If a_min or a_max are array_like, then the three - /// arrays will be broadcasted to match their shapes. - /// - /// - /// The results will be placed in this array.

- /// It may be the input - /// array for in-place clipping.

- /// out must be of the right shape - /// to hold the output.

- /// Its type is preserved. - /// - /// - /// An array with the elements of a, but where values - /// < a_min are replaced with a_min, and those > a_max - /// with a_max. - /// - public NDarray clip(NDarray a_min, NDarray a_max, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a_min, - a_max, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("clip", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the non-negative square-root of an array, element-wise.

- /// - /// 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. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// 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. - /// - public NDarray sqrt(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("sqrt", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the cube-root of an array, element-wise. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// 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. - /// - public NDarray cbrt(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("cbrt", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the element-wise square of the input. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// Element-wise x*x, of the same shape and dtype as x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray square(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("square", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Calculate the absolute value element-wise.

- /// - /// np.abs is a shorthand for this function. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// An ndarray containing the absolute value of - /// each element in x.

- /// For complex input, a + ib, the - /// absolute value is . - /// This is a scalar if x is a scalar. - /// - public NDarray absolute(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("absolute", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The absolute values of x, the returned values are always floats.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray fabs(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("fabs", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// 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.

- /// - /// Notes - /// - /// There is more than one definition of sign in common use for complex - /// numbers.

- /// The definition used here is equivalent to - /// which is different from a common alternative, . - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The sign of x.

- /// - /// This is a scalar if x is a scalar. - /// - public NDarray sign(NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("sign", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the Heaviside step function.

- /// - /// The Heaviside step function is defined as: - /// - /// where x2 is often taken to be 0.5, but 0 and 1 are also sometimes used.

- /// - /// Notes - /// - /// References - /// - /// - /// The value of the function when x1 is 0. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The output array, element-wise Heaviside step function of x1. - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray heaviside(NDarray x2, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x2, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("heaviside", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Element-wise maximum of array elements.

- /// - /// Compare two arrays and returns 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.

- /// - /// 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. - /// - /// - /// The arrays holding the elements to be compared.

- /// They must have - /// the same shape, or shapes that can be broadcast to a single shape. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The maximum of x1 and x2, element-wise.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray maximum(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("maximum", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Element-wise minimum of array elements.

- /// - /// Compare two arrays and returns 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.

- /// - /// 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. - /// - /// - /// The arrays holding the elements to be compared.

- /// They must have - /// the same shape, or shapes that can be broadcast to a single shape. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The minimum of x1 and x2, element-wise.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray minimum(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("minimum", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Element-wise maximum of array elements.

- /// - /// Compare two arrays and returns 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.

- /// - /// Notes - /// - /// 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. - /// - /// - /// The arrays holding the elements to be compared.

- /// They must have - /// the same shape. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The maximum of x1 and x2, element-wise.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray fmax(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("fmax", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Element-wise minimum of array elements.

- /// - /// Compare two arrays and returns 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.

- /// - /// Notes - /// - /// 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. - /// - /// - /// The arrays holding the elements to be compared.

- /// They must have - /// the same shape. - /// - /// - /// A location into which the result is stored.

- /// If provided, it must have - /// a shape that the inputs broadcast to.

- /// If not provided or None, - /// a freshly-allocated array is returned.

- /// A tuple (possible only as a - /// keyword argument) must have length equal to the number of outputs. - /// - /// - /// Values of True indicate to calculate the ufunc at that position, values - /// of False indicate to leave the value in the output alone. - /// - /// - /// The minimum of x1 and x2, element-wise.

- /// - /// This is a scalar if both x1 and x2 are scalars. - /// - public NDarray fmin(NDarray x1, NDarray @out = null, NDarray @where = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - x1, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (@where!=null) kwargs["where"]=ToPython(@where); - dynamic py = __self__.InvokeMethod("fmin", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Replace NaN with zero and infinity with large finite numbers.

- /// - /// If x is inexact, NaN is replaced by zero, and infinity and -infinity - /// replaced by the respectively largest and most negative finite floating - /// point values representable by x.dtype.

- /// - /// For complex dtypes, the above is applied to each of the real and - /// imaginary components of x separately.

- /// - /// If x is not inexact, then no replacements are made.

- /// - /// 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. - /// - /// - /// Whether to create a copy of x (True) or to replace values - /// in-place (False).

- /// The in-place operation only occurs if - /// casting to an array does not require a copy.

- /// - /// Default is True. - /// - /// - /// x, with the non-finite values replaced.

- /// If copy is False, this may - /// be x itself. - /// - public NDarray nan_to_num(bool? copy = true) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (copy!=true) kwargs["copy"]=ToPython(copy); - dynamic py = __self__.InvokeMethod("nan_to_num", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// If complex input returns a real array if complex parts are close to zero.

- /// - /// “Close to zero” is defined as tol * (machine epsilon of the type for - /// a).

- /// - /// Notes - /// - /// Machine epsilon varies from machine to machine and between data types - /// but Python floats on most platforms have a machine epsilon equal to - /// 2.2204460492503131e-16. You can use ‘np.finfo(float).eps’ to print - /// out the machine epsilon for floats. - /// - /// - /// Tolerance in machine epsilons for the complex part of the elements - /// in the array. - /// - /// - /// If a is real, the type of a is used for the output.

- /// If a - /// has complex elements, the returned type is float. - /// - public NDarray real_if_close(float tol = 100) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (tol!=100) kwargs["tol"]=ToPython(tol); - dynamic py = __self__.InvokeMethod("real_if_close", pyargs, kwargs); - return ToCsharp(py); - } - - /* - /// - /// One-dimensional linear interpolation.

- /// - /// Returns the one-dimensional piecewise linear interpolant to a function - /// with given discrete data points (xp, fp), evaluated at x.

- /// - /// Notes - /// - /// Does not check that the x-coordinate sequence xp is increasing.

- /// - /// If xp is not increasing, the results are nonsense.

- /// - /// A simple check for increasing is: - /// - /// - /// The x-coordinates of the data points, must be increasing if argument - /// period is not specified.

- /// Otherwise, xp is internally sorted after - /// normalizing the periodic boundaries with xp = xp % period. - /// - /// - /// The y-coordinates of the data points, same length as xp. - /// - /// - /// Value to return for x < xp[0], default is fp[0]. - /// - /// - /// Value to return for x > xp[-1], default is fp[-1]. - /// - /// - /// A period for the x-coordinates.

- /// This parameter allows the proper - /// interpolation of angular x-coordinates.

- /// Parameters left and right - /// are ignored if period is specified. - /// - /// - /// The interpolated values, same shape as x. - /// - public float or complex (corresponding to fp) or ndarray interp(1-D sequence of floats xp, 1-D sequence of float or complex fp, optional float or complex corresponding to fp left = null, optional float or complex corresponding to fp right = null, None or float period = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - xp, - fp, - }); - var kwargs=new PyDict(); - if (left!=null) kwargs["left"]=ToPython(left); - if (right!=null) kwargs["right"]=ToPython(right); - if (period!=null) kwargs["period"]=ToPython(period); - dynamic py = __self__.InvokeMethod("interp", pyargs, kwargs); - return ToCsharp(py); - } - */ - - /// - /// Pads an array.

- /// - /// Notes - /// - /// For an array with rank greater than 1, some of the padding of later - /// axes is calculated from padding of previous axes.

- /// This is easiest to - /// think about with a rank 2 array where the corners of the padded array - /// are calculated by using padded values from the first axis.

- /// - /// The padding function, if used, should return a rank 1 array equal in - /// length to the vector argument with padded values replaced.

- /// It has the - /// following signature: - /// - /// where - /// - /// - /// Number of values padded to the edges of each axis.

- /// - /// ((before_1, after_1), … (before_N, after_N)) unique pad widths - /// for each axis.

- /// - /// ((before, after),) yields same before and after pad for each axis.

- /// - /// (pad,) or int is a shortcut for before = after = pad width for all - /// axes. - /// - /// - /// One of the following string values or a user supplied function. - /// - /// - /// Used in ‘maximum’, ‘mean’, ‘median’, and ‘minimum’. Number of - /// values at edge of each axis used to calculate the statistic value.

- /// - /// ((before_1, after_1), … (before_N, after_N)) unique statistic - /// lengths for each axis.

- /// - /// ((before, after),) yields same before and after statistic lengths - /// for each axis.

- /// - /// (stat_length,) or int is a shortcut for before = after = statistic - /// length for all axes.

- /// - /// Default is None, to use the entire axis. - /// - /// - /// Used in ‘constant’. The values to set the padded values for each - /// axis.

- /// - /// ((before_1, after_1), … (before_N, after_N)) unique pad constants - /// for each axis.

- /// - /// ((before, after),) yields same before and after constants for each - /// axis.

- /// - /// (constant,) or int is a shortcut for before = after = constant for - /// all axes.

- /// - /// Default is 0. - /// - /// - /// Used in ‘linear_ramp’. The values used for the ending value of the - /// linear_ramp and that will form the edge of the padded array.

- /// - /// ((before_1, after_1), … (before_N, after_N)) unique end values - /// for each axis.

- /// - /// ((before, after),) yields same before and after end values for each - /// axis.

- /// - /// (constant,) or int is a shortcut for before = after = end value for - /// all axes.

- /// - /// Default is 0. - /// - /// - /// Used in ‘reflect’, and ‘symmetric’. The ‘even’ style is the - /// default with an unaltered reflection around the edge value.

- /// For - /// the ‘odd’ style, the extended part of the array is created by - /// subtracting the reflected values from two times the edge value. - /// - /// - /// Padded array of rank equal to array with shape increased - /// according to pad_width. - /// - public NDarray pad(NDarray pad_width, string mode, int[] stat_length = null, int[] constant_values = null, int[] end_values = null, string reflect_type = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - pad_width, - mode, - }); - var kwargs=new PyDict(); - if (stat_length!=null) kwargs["stat_length"]=ToPython(stat_length); - if (constant_values!=null) kwargs["constant_values"]=ToPython(constant_values); - if (end_values!=null) kwargs["end_values"]=ToPython(end_values); - if (reflect_type!=null) kwargs["reflect_type"]=ToPython(reflect_type); - dynamic py = __self__.InvokeMethod("pad", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Test whether each element of a 1-D array is also present in a second array.

- /// - /// Returns a boolean array the same length as ar1 that is True - /// where an element of ar1 is in ar2 and False otherwise.

- /// - /// We recommend using isin instead of in1d for new code.

- /// - /// Notes - /// - /// in1d can be considered as an element-wise function version of the - /// python keyword in, for 1-D sequences.

- /// in1d(a, b) is roughly - /// equivalent to np.array([item in b for item in a]).

- /// - /// However, this idea fails if ar2 is a set, or similar (non-sequence) - /// container: As ar2 is converted to an array, in those cases - /// asarray(ar2) is an object array rather than the expected array of - /// contained values. - /// - /// - /// The values against which to test each value of ar1. - /// - /// - /// If True, the input arrays are both assumed to be unique, which - /// can speed up the calculation.

- /// Default is False. - /// - /// - /// If True, the values in the returned array are inverted (that is, - /// False where an element of ar1 is in ar2 and True otherwise).

- /// - /// Default is False.

- /// np.in1d(a, b, invert=True) is equivalent - /// to (but is faster than) np.invert(in1d(a, b)). - /// - /// - /// The values ar1[in1d] are in ar2. - /// - public NDarray in1d(NDarray ar2, bool? assume_unique = false, bool? invert = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - ar2, - }); - var kwargs=new PyDict(); - if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique); - if (invert!=false) kwargs["invert"]=ToPython(invert); - dynamic py = __self__.InvokeMethod("in1d", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Find the intersection of two arrays.

- /// - /// Return the sorted, unique values that are in both of the input arrays. - /// - /// - /// Input arrays.

- /// Will be flattened if not already 1D. - /// - /// - /// If True, the input arrays are both assumed to be unique, which - /// can speed up the calculation.

- /// Default is False. - /// - /// - /// If True, the indices which correspond to the intersection of the two - /// arrays are returned.

- /// The first instance of a value is used if there are - /// multiple.

- /// Default is False. - /// - /// - /// A tuple of: - /// intersect1d - /// Sorted 1D array of common and unique elements. - /// comm1 - /// The indices of the first occurrences of the common values in ar1. - /// Only provided if return_indices is True. - /// comm2 - /// The indices of the first occurrences of the common values in ar2. - /// Only provided if return_indices is True. - /// - public (NDarray, NDarray, NDarray) intersect1d(NDarray ar1, bool assume_unique = false, bool return_indices = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - ar1, - }); - var kwargs=new PyDict(); - if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique); - if (return_indices!=false) kwargs["return_indices"]=ToPython(return_indices); - dynamic py = __self__.InvokeMethod("intersect1d", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1]), ToCsharp(py[2])); - } - - /// - /// Calculates element in test_elements, broadcasting over element only.

- /// - /// Returns a boolean array of the same shape as element that is True - /// where an element of element is in test_elements and False otherwise.

- /// - /// Notes - /// - /// isin is an element-wise function version of the python keyword in.

- /// - /// isin(a, b) is roughly equivalent to - /// np.array([item in b for item in a]) if a and b are 1-D sequences.

- /// - /// element and test_elements are converted to arrays if they are not - /// already.

- /// If test_elements is a set (or other non-sequence collection) - /// it will be converted to an object array with one element, rather than an - /// array of the values contained in test_elements.

- /// This is a consequence - /// of the array constructor’s way of handling non-sequence collections.

- /// - /// Converting the set to a list usually gives the desired behavior. - /// - /// - /// The values against which to test each value of element.

- /// - /// This argument is flattened if it is an array or array_like.

- /// - /// See notes for behavior with non-array-like parameters. - /// - /// - /// If True, the input arrays are both assumed to be unique, which - /// can speed up the calculation.

- /// Default is False. - /// - /// - /// If True, the values in the returned array are inverted, as if - /// calculating element not in test_elements.

- /// Default is False.

- /// - /// np.isin(a, b, invert=True) is equivalent to (but faster - /// than) np.invert(np.isin(a, b)). - /// - /// - /// Has the same shape as element.

- /// The values element[isin] - /// are in test_elements. - /// - public NDarray isin(NDarray test_elements, bool? assume_unique = false, bool? invert = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - test_elements, - }); - var kwargs=new PyDict(); - if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique); - if (invert!=false) kwargs["invert"]=ToPython(invert); - dynamic py = __self__.InvokeMethod("isin", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Find the set difference of two arrays.

- /// - /// Return the unique values in ar1 that are not in ar2. - /// - /// - /// Input comparison array. - /// - /// - /// If True, the input arrays are both assumed to be unique, which - /// can speed up the calculation.

- /// Default is False. - /// - /// - /// 1D array of values in ar1 that are not in ar2. The result - /// is sorted when assume_unique=False, but otherwise only sorted - /// if the input is sorted. - /// - public NDarray setdiff1d(NDarray ar2, bool assume_unique = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - ar2, - }); - var kwargs=new PyDict(); - if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique); - dynamic py = __self__.InvokeMethod("setdiff1d", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Find the set exclusive-or of two arrays.

- /// - /// Return the sorted, unique values that are in only one (not both) of the - /// input arrays. - /// - /// - /// Input arrays. - /// - /// - /// If True, the input arrays are both assumed to be unique, which - /// can speed up the calculation.

- /// Default is False. - /// - /// - /// Sorted 1D array of unique values that are in only one of the input - /// arrays. - /// - public NDarray setxor1d(NDarray ar1, bool assume_unique = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - ar1, - }); - var kwargs=new PyDict(); - if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique); - dynamic py = __self__.InvokeMethod("setxor1d", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Find the union of two arrays.

- /// - /// Return the unique, sorted array of values that are in either of the two - /// input arrays. - /// - /// - /// Input arrays.

- /// They are flattened if they are not already 1D. - /// - /// - /// Unique, sorted union of the input arrays. - /// - public NDarray union1d(NDarray ar1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - ar1, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("union1d", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return a sorted copy of an array.

- /// - /// Notes - /// - /// The various sorting algorithms are characterized by their average speed, - /// worst case performance, work space size, and whether they are stable.

- /// A - /// stable sort keeps items with the same key in the same relative - /// order.

- /// The three available algorithms have the following - /// properties: - /// - /// All the sort algorithms make temporary copies of the data when - /// sorting along any but the last axis.

- /// Consequently, sorting along - /// the last axis is faster and uses less space than sorting along - /// any other axis.

- /// - /// The sort order for complex numbers is lexicographic.

- /// If both the real - /// and imaginary parts are non-nan then the order is determined by the - /// real parts except when they are equal, in which case the order is - /// determined by the imaginary parts.

- /// - /// Previous to numpy 1.4.0 sorting real and complex arrays containing nan - /// values led to undefined behaviour.

- /// In numpy versions >= 1.4.0 nan - /// values are sorted to the end.

- /// The extended sort order is: - /// - /// where R is a non-nan real value.

- /// Complex values with the same nan - /// placements are sorted according to the non-nan part if it exists.

- /// - /// Non-nan values are sorted as before.

- /// - /// quicksort has been changed to an introsort which will switch - /// heapsort when it does not make enough progress.

- /// This makes its - /// worst case O(n*log(n)).

- /// - /// ‘stable’ automatically choses the best stable sorting algorithm - /// for the data type being sorted.

- /// It is currently mapped to - /// merge sort. - /// - /// - /// Axis along which to sort.

- /// If None, the array is flattened before - /// sorting.

- /// The default is -1, which sorts along the last axis. - /// - /// - /// Sorting algorithm.

- /// Default is ‘quicksort’. - /// - /// - /// When a is an array with fields defined, this argument specifies - /// which fields to compare first, second, etc.

- /// A single field can - /// be specified as a string, and not all fields need be specified, - /// but unspecified fields will still be used, in the order in which - /// they come up in the dtype, to break ties. - /// - /// - /// Array of the same type and shape as a. - /// - public NDarray sort(int? axis = -1, string kind = "quicksort", string order = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=-1) kwargs["axis"]=ToPython(axis); - if (kind!="quicksort") kwargs["kind"]=ToPython(kind); - if (order!=null) kwargs["order"]=ToPython(order); - dynamic py = __self__.InvokeMethod("sort", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Perform an indirect stable sort using a sequence of keys.

- /// - /// Given multiple sorting keys, which can be interpreted as columns in a - /// spreadsheet, lexsort returns an array of integer indices that describes - /// the sort order by multiple columns.

- /// The last key in the sequence is used - /// for the primary sort order, the second-to-last key for the secondary sort - /// order, and so on.

- /// The keys argument must be a sequence of objects that - /// can be converted to arrays of the same shape.

- /// If a 2D array is provided - /// for the keys argument, it’s rows are interpreted as the sorting keys and - /// sorting is according to the last row, second last row etc. - /// - /// - /// Axis to be indirectly sorted.

- /// By default, sort over the last axis. - /// - /// - /// Array of indices that sort the keys along the specified axis. - /// - public NDarray lexsort(int? axis = -1) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=-1) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("lexsort", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns the indices that would sort an array.

- /// - /// Perform an indirect sort along the given axis using the algorithm specified - /// by the kind keyword.

- /// It returns an array of indices of the same shape as - /// a that index data along the given axis in sorted order.

- /// - /// Notes - /// - /// See sort for notes on the different sorting algorithms.

- /// - /// As of NumPy 1.4.0 argsort works with real/complex arrays containing - /// nan values.

- /// The enhanced sort order is documented in sort. - /// - /// - /// Axis along which to sort.

- /// The default is -1 (the last axis).

- /// If None, - /// the flattened array is used. - /// - /// - /// Sorting algorithm. - /// - /// - /// When a is an array with fields defined, this argument specifies - /// which fields to compare first, second, etc.

- /// A single field can - /// be specified as a string, and not all fields need be specified, - /// but unspecified fields will still be used, in the order in which - /// they come up in the dtype, to break ties. - /// - /// - /// Array of indices that sort a along the specified axis.

- /// - /// If a is one-dimensional, a[index_array] yields a sorted a.

- /// - /// More generally, np.take_along_axis(a, index_array, axis=a) always - /// yields the sorted a, irrespective of dimensionality. - /// - public NDarray argsort(int? axis = -1, string kind = "quicksort", string order = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=-1) kwargs["axis"]=ToPython(axis); - if (kind!="quicksort") kwargs["kind"]=ToPython(kind); - if (order!=null) kwargs["order"]=ToPython(order); - dynamic py = __self__.InvokeMethod("argsort", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return a copy of an array sorted along the first axis.

- /// - /// Notes - /// - /// np.msort(a) is equivalent to np.sort(a, axis=0). - /// - /// - /// Array of the same type and shape as a. - /// - public NDarray msort() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("msort"); - return ToCsharp(py); - } - - /// - /// Sort a complex array using the real part first, then the imaginary part. - /// - /// - /// Always returns a sorted complex array. - /// - public NDarray sort_complex() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("sort_complex"); - return ToCsharp(py); - } - - /// - /// Return a partitioned copy of an array.

- /// - /// Creates a copy of the array with its elements rearranged in such a - /// way that the value of the element in k-th position is in the - /// position it would be in a sorted array.

- /// All elements smaller than - /// the k-th element are moved before this element and all equal or - /// greater are moved behind it.

- /// The ordering of the elements in the two - /// partitions is undefined.

- /// - /// Notes - /// - /// The various selection algorithms are characterized by their average - /// speed, worst case performance, work space size, and whether they are - /// stable.

- /// A stable sort keeps items with the same key in the same - /// relative order.

- /// The available algorithms have the following - /// properties: - /// - /// All the partition algorithms make temporary copies of the data when - /// partitioning along any but the last axis.

- /// Consequently, - /// partitioning along the last axis is faster and uses less space than - /// partitioning along any other axis.

- /// - /// The sort order for complex numbers is lexicographic.

- /// If both the - /// real and imaginary parts are non-nan then the order is determined by - /// the real parts except when they are equal, in which case the order - /// is determined by the imaginary parts. - /// - /// - /// Element index to partition by.

- /// The k-th value of the element - /// will be in its final sorted position and all smaller elements - /// will be moved before it and all equal or greater elements behind - /// it.

- /// The order of all elements in the partitions is undefined.

- /// If - /// provided with a sequence of k-th it will partition all elements - /// indexed by k-th of them into their sorted position at once. - /// - /// - /// Axis along which to sort.

- /// If None, the array is flattened before - /// sorting.

- /// The default is -1, which sorts along the last axis. - /// - /// - /// Selection algorithm.

- /// Default is ‘introselect’. - /// - /// - /// When a is an array with fields defined, this argument - /// specifies which fields to compare first, second, etc.

- /// A single - /// field can be specified as a string.

- /// Not all fields need be - /// specified, but unspecified fields will still be used, in the - /// order in which they come up in the dtype, to break ties. - /// - /// - /// Array of the same type and shape as a. - /// - public NDarray partition(int[] kth, int? axis = -1, string kind = "introselect", string order = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - kth, - }); - var kwargs=new PyDict(); - if (axis!=-1) kwargs["axis"]=ToPython(axis); - if (kind!="introselect") kwargs["kind"]=ToPython(kind); - if (order!=null) kwargs["order"]=ToPython(order); - dynamic py = __self__.InvokeMethod("partition", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Perform an indirect partition along the given axis using the - /// algorithm specified by the kind keyword.

- /// It returns an array of - /// indices of the same shape as a that index data along the given - /// axis in partitioned order.

- /// - /// Notes - /// - /// See partition for notes on the different selection algorithms. - /// - /// - /// Element index to partition by.

- /// The k-th element will be in its - /// final sorted position and all smaller elements will be moved - /// before it and all larger elements behind it.

- /// The order all - /// elements in the partitions is undefined.

- /// If provided with a - /// sequence of k-th it will partition all of them into their sorted - /// position at once. - /// - /// - /// Axis along which to sort.

- /// The default is -1 (the last axis).

- /// If - /// None, the flattened array is used. - /// - /// - /// Selection algorithm.

- /// Default is ‘introselect’ - /// - /// - /// When a is an array with fields defined, this argument - /// specifies which fields to compare first, second, etc.

- /// A single - /// field can be specified as a string, and not all fields need be - /// specified, but unspecified fields will still be used, in the - /// order in which they come up in the dtype, to break ties. - /// - /// - /// Array of indices that partition a along the specified axis.

- /// - /// If a is one-dimensional, a[index_array] yields a partitioned a.

- /// - /// More generally, np.take_along_axis(a, index_array, axis=a) always - /// yields the partitioned a, irrespective of dimensionality. - /// - public NDarray argpartition(int[] kth, int? axis = -1, string kind = "introselect", string order = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - kth, - }); - var kwargs=new PyDict(); - if (axis!=-1) kwargs["axis"]=ToPython(axis); - if (kind!="introselect") kwargs["kind"]=ToPython(kind); - if (order!=null) kwargs["order"]=ToPython(order); - dynamic py = __self__.InvokeMethod("argpartition", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns the indices of the maximum values along an axis.

- /// - /// Notes - /// - /// In case of multiple occurrences of the maximum values, the indices - /// corresponding to the first occurrence are returned. - /// - /// - /// By default, the index is into the flattened array, otherwise - /// along the specified axis. - /// - /// - /// If provided, the result will be inserted into this array.

- /// It should - /// be of the appropriate shape and dtype. - /// - /// - /// Array of indices into the array.

- /// It has the same shape as a.shape - /// with the dimension along axis removed. - /// - public NDarray argmax(int? axis = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("argmax", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the indices of the maximum values in the specified axis ignoring - /// NaNs.

- /// For all-NaN slices ValueError is raised.

- /// Warning: the - /// results cannot be trusted if a slice contains only NaNs and -Infs. - /// - /// - /// Axis along which to operate.

- /// By default flattened input is used. - /// - /// - /// An array of indices or a single index value. - /// - public NDarray nanargmax(int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("nanargmax", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Returns the indices of the minimum values along an axis.

- /// - /// Notes - /// - /// In case of multiple occurrences of the minimum values, the indices - /// corresponding to the first occurrence are returned. - /// - /// - /// By default, the index is into the flattened array, otherwise - /// along the specified axis. - /// - /// - /// If provided, the result will be inserted into this array.

- /// It should - /// be of the appropriate shape and dtype. - /// - /// - /// Array of indices into the array.

- /// It has the same shape as a.shape - /// with the dimension along axis removed. - /// - public NDarray argmin(int? axis = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("argmin", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the indices of the minimum values in the specified axis ignoring - /// NaNs.

- /// For all-NaN slices ValueError is raised.

- /// Warning: the results - /// cannot be trusted if a slice contains only NaNs and Infs. - /// - /// - /// Axis along which to operate.

- /// By default flattened input is used. - /// - /// - /// An array of indices or a single index value. - /// - public NDarray nanargmin(int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("nanargmin", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Find the indices of array elements that are non-zero, grouped by element.

- /// - /// Notes - /// - /// np.argwhere(a) is the same as np.transpose(np.nonzero(a)).

- /// - /// The output of argwhere is not suitable for indexing arrays.

- /// - /// For this purpose use nonzero(a) instead. - /// - /// - /// Indices of elements that are non-zero.

- /// Indices are grouped by element. - /// - public NDarray argwhere() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("argwhere"); - return ToCsharp(py); - } - - /// - /// Return indices that are non-zero in the flattened version of a.

- /// - /// This is equivalent to np.nonzero(np.ravel(a))[0]. - /// - /// - /// Output array, containing the indices of the elements of a.ravel() - /// that are non-zero. - /// - public NDarray flatnonzero() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("flatnonzero"); - return ToCsharp(py); - } - - /// - /// Find indices where elements should be inserted to maintain order.

- /// - /// Find the indices into a sorted array a such that, if the - /// corresponding elements in v were inserted before the indices, the - /// order of a would be preserved.

- /// - /// Assuming that a is sorted: - /// - /// Notes - /// - /// Binary search is used to find the required insertion points.

- /// - /// As of NumPy 1.4.0 searchsorted works with real/complex arrays containing - /// nan values.

- /// The enhanced sort order is documented in sort.

- /// - /// This function is a faster version of the builtin python bisect.bisect_left - /// (side='left') and bisect.bisect_right (side='right') functions, - /// which is also vectorized in the v argument. - /// - /// - /// Values to insert into a. - /// - /// - /// If ‘left’, the index of the first suitable location found is given.

- /// - /// If ‘right’, return the last such index.

- /// If there is no suitable - /// index, return either 0 or N (where N is the length of a). - /// - /// - /// Optional array of integer indices that sort array a into ascending - /// order.

- /// They are typically the result of argsort. - /// - /// - /// Array of insertion points with the same shape as v. - /// - public NDarray searchsorted(NDarray v, string side = "left", NDarray sorter = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - v, - }); - var kwargs=new PyDict(); - if (side!="left") kwargs["side"]=ToPython(side); - if (sorter!=null) kwargs["sorter"]=ToPython(sorter); - dynamic py = __self__.InvokeMethod("searchsorted", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Return the elements of an array that satisfy some condition.

- /// - /// This is equivalent to np.compress(ravel(condition), ravel(arr)).

- /// If - /// condition is boolean np.extract is equivalent to arr[condition].

- /// - /// Note that place does the exact opposite of extract. - /// - /// - /// Input array of the same size as condition. - /// - /// - /// Rank 1 array of values from arr where condition is True. - /// - public NDarray extract(NDarray arr) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - arr, - }); - var kwargs=new PyDict(); - dynamic py = __self__.InvokeMethod("extract", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Counts the number of non-zero values in the array a.

- /// - /// The word “non-zero” is in reference to the Python 2.x - /// built-in method __nonzero__() (renamed __bool__() - /// in Python 3.x) of Python objects that tests an object’s - /// “truthfulness”. For example, any number is considered - /// truthful if it is nonzero, whereas any string is considered - /// truthful if it is not the empty string.

- /// Thus, this function - /// (recursively) counts how many elements in a (and in - /// sub-arrays thereof) have their __nonzero__() or __bool__() - /// method evaluated to True. - /// - /// - /// Axis or tuple of axes along which to count non-zeros.

- /// - /// Default is None, meaning that non-zeros will be counted - /// along a flattened version of a. - /// - /// - /// Number of non-zero values in the array along a given axis.

- /// - /// Otherwise, the total number of non-zero values in the array - /// is returned. - /// - public NDarray count_nonzero(Axis axis) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("count_nonzero", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Counts the number of non-zero values in the array a.

- /// - /// The word “non-zero” is in reference to the Python 2.x - /// built-in method __nonzero__() (renamed __bool__() - /// in Python 3.x) of Python objects that tests an object’s - /// “truthfulness”. For example, any number is considered - /// truthful if it is nonzero, whereas any string is considered - /// truthful if it is not the empty string.

- /// Thus, this function - /// (recursively) counts how many elements in a (and in - /// sub-arrays thereof) have their __nonzero__() or __bool__() - /// method evaluated to True. - /// - /// - /// Number of non-zero values in the array along a given axis.

- /// - /// Otherwise, the total number of non-zero values in the array - /// is returned. - /// - public int count_nonzero() - { - //auto-generated code, do not change - var __self__=self; - dynamic py = __self__.InvokeMethod("count_nonzero"); - return ToCsharp(py); - } - - /// - /// Return minimum of an array or minimum along an axis, ignoring any NaNs.

- /// - /// When all-NaN slices are encountered a RuntimeWarning is raised and - /// Nan is returned for that slice.

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

- /// - /// Positive infinity is treated as a very large number and negative - /// infinity is treated as a very small (i.e.

- /// negative) number.

- /// - /// If the input has a integer type the function is equivalent to np.min. - /// - /// - /// Axis or axes along which the minimum is computed.

- /// The default is to compute - /// the minimum of the flattened array. - /// - /// - /// Alternate output array in which to place the result.

- /// The default - /// is None; if provided, it must have the same shape as the - /// expected output, but the type will be cast if necessary.

- /// See - /// doc.ufuncs for details. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the original a.

- /// - /// If the value is anything but the default, then - /// keepdims will be passed through to the min method - /// of sub-classes of ndarray.

- /// If the sub-classes methods - /// does not implement keepdims any exceptions will be raised. - /// - /// - /// An array with the same shape as a, with the specified axis - /// removed.

- /// If a is a 0-d array, or if axis is None, an ndarray - /// scalar is returned.

- /// The same dtype as a is returned. - /// - public NDarray nanmin(Axis axis = null, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanmin", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return the maximum of an array or maximum along an axis, ignoring any - /// NaNs.

- /// When all-NaN slices are encountered a RuntimeWarning is - /// raised and NaN is returned for that slice.

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

- /// - /// Positive infinity is treated as a very large number and negative - /// infinity is treated as a very small (i.e.

- /// negative) number.

- /// - /// If the input has a integer type the function is equivalent to np.max. - /// - /// - /// Axis or axes along which the maximum is computed.

- /// The default is to compute - /// the maximum of the flattened array. - /// - /// - /// Alternate output array in which to place the result.

- /// The default - /// is None; if provided, it must have the same shape as the - /// expected output, but the type will be cast if necessary.

- /// See - /// doc.ufuncs for details. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the original a.

- /// - /// If the value is anything but the default, then - /// keepdims will be passed through to the max method - /// of sub-classes of ndarray.

- /// If the sub-classes methods - /// does not implement keepdims any exceptions will be raised. - /// - /// - /// An array with the same shape as a, with the specified axis removed.

- /// - /// If a is a 0-d array, or if axis is None, an ndarray scalar is - /// returned.

- /// The same dtype as a is returned. - /// - public NDarray nanmax(Axis axis = null, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanmax", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Range of values (maximum - minimum) along an axis.

- /// - /// The name of the function comes from the acronym for ‘peak to peak’. - /// - /// - /// Axis along which to find the peaks.

- /// By default, flatten the - /// array.

- /// axis may be negative, in - /// which case it counts from the last to the first axis.

- /// - /// If this is a tuple of ints, a reduction is performed on multiple - /// axes, instead of a single axis or all the axes as before. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type of the output values will be cast if necessary. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the input array.

- /// - /// If the default value is passed, then keepdims will not be - /// passed through to the ptp method of sub-classes of - /// ndarray, however any non-default value will be.

- /// If the - /// sub-class’ method does not implement keepdims any - /// exceptions will be raised. - /// - /// - /// A new array holding the result, unless out was - /// specified, in which case a reference to out is returned. - /// - public NDarray ptp(Axis axis = null, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("ptp", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the q-th percentile of the data along the specified axis.

- /// - /// Returns the q-th percentile(s) of the array elements.

- /// - /// Notes - /// - /// Given a vector V of length N, the q-th percentile of - /// V is the value q/100 of the way from the minimum to the - /// maximum in a sorted copy of V.

- /// The values and distances of - /// the two nearest neighbors as well as the interpolation parameter - /// will determine the percentile if the normalized ranking does not - /// match the location of q exactly.

- /// This function is the same as - /// the median if q=50, the same as the minimum if q=0 and the - /// same as the maximum if q=100. - /// - /// - /// Percentile or sequence of percentiles to compute, which must be between - /// 0 and 100 inclusive. - /// - /// - /// Axis or axes along which the percentiles are computed.

- /// The - /// default is to compute the percentile(s) along a flattened - /// version of the array. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow the input array a to be modified by intermediate - /// calculations, to save memory.

- /// In this case, the contents of the input - /// a after this function completes is undefined. - /// - /// - /// This optional parameter specifies the interpolation method to - /// use when the desired percentile lies between two data points - /// i < j: - /// - /// - /// If this is set to True, the axes which are reduced are left in - /// the result as dimensions with size one.

- /// With this option, the - /// result will broadcast correctly against the original array a. - /// - /// - /// If q is a single percentile and axis=None, then the result - /// is a scalar.

- /// If multiple percentiles are given, first axis of - /// the result corresponds to the percentiles.

- /// The other axes are - /// the axes that remain after the reduction of a.

- /// If the input - /// contains integers or floats smaller than float64, the output - /// data-type is float64. Otherwise, the output data-type is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public NDarray percentile(NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - q, - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation); - if (keepdims!=false) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("percentile", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the q-th percentile of the data along the specified axis.

- /// - /// Returns the q-th percentile(s) of the array elements.

- /// - /// Notes - /// - /// Given a vector V of length N, the q-th percentile of - /// V is the value q/100 of the way from the minimum to the - /// maximum in a sorted copy of V.

- /// The values and distances of - /// the two nearest neighbors as well as the interpolation parameter - /// will determine the percentile if the normalized ranking does not - /// match the location of q exactly.

- /// This function is the same as - /// the median if q=50, the same as the minimum if q=0 and the - /// same as the maximum if q=100. - /// - /// - /// Percentile or sequence of percentiles to compute, which must be between - /// 0 and 100 inclusive. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow the input array a to be modified by intermediate - /// calculations, to save memory.

- /// In this case, the contents of the input - /// a after this function completes is undefined. - /// - /// - /// This optional parameter specifies the interpolation method to - /// use when the desired percentile lies between two data points - /// i < j: - /// - /// - /// If q is a single percentile and axis=None, then the result - /// is a scalar.

- /// If multiple percentiles are given, first axis of - /// the result corresponds to the percentiles.

- /// The other axes are - /// the axes that remain after the reduction of a.

- /// If the input - /// contains integers or floats smaller than float64, the output - /// data-type is float64. Otherwise, the output data-type is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public double percentile(NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - q, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation); - dynamic py = __self__.InvokeMethod("percentile", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the qth percentile of the data along the specified axis, - /// while ignoring nan values.

- /// - /// Returns the qth percentile(s) of the array elements.

- /// - /// Notes - /// - /// Given a vector V of length N, the q-th percentile of - /// V is the value q/100 of the way from the minimum to the - /// maximum in a sorted copy of V.

- /// The values and distances of - /// the two nearest neighbors as well as the interpolation parameter - /// will determine the percentile if the normalized ranking does not - /// match the location of q exactly.

- /// This function is the same as - /// the median if q=50, the same as the minimum if q=0 and the - /// same as the maximum if q=100. - /// - /// - /// Percentile or sequence of percentiles to compute, which must be between - /// 0 and 100 inclusive. - /// - /// - /// Axis or axes along which the percentiles are computed.

- /// The - /// default is to compute the percentile(s) along a flattened - /// version of the array. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow the input array a to be modified by intermediate - /// calculations, to save memory.

- /// In this case, the contents of the input - /// a after this function completes is undefined. - /// - /// - /// This optional parameter specifies the interpolation method to - /// use when the desired percentile lies between two data points - /// i < j: - /// - /// - /// If this is set to True, the axes which are reduced are left in - /// the result as dimensions with size one.

- /// With this option, the - /// result will broadcast correctly against the original array a.

- /// - /// If this is anything but the default value it will be passed - /// through (in the special case of an empty array) to the - /// mean function of the underlying array.

- /// If the array is - /// a sub-class and mean does not have the kwarg keepdims this - /// will raise a RuntimeError. - /// - /// - /// If q is a single percentile and axis=None, then the result - /// is a scalar.

- /// If multiple percentiles are given, first axis of - /// the result corresponds to the percentiles.

- /// The other axes are - /// the axes that remain after the reduction of a.

- /// If the input - /// contains integers or floats smaller than float64, the output - /// data-type is float64. Otherwise, the output data-type is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public NDarray nanpercentile(NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - q, - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanpercentile", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the qth percentile of the data along the specified axis, - /// while ignoring nan values.

- /// - /// Returns the qth percentile(s) of the array elements.

- /// - /// Notes - /// - /// Given a vector V of length N, the q-th percentile of - /// V is the value q/100 of the way from the minimum to the - /// maximum in a sorted copy of V.

- /// The values and distances of - /// the two nearest neighbors as well as the interpolation parameter - /// will determine the percentile if the normalized ranking does not - /// match the location of q exactly.

- /// This function is the same as - /// the median if q=50, the same as the minimum if q=0 and the - /// same as the maximum if q=100. - /// - /// - /// Percentile or sequence of percentiles to compute, which must be between - /// 0 and 100 inclusive. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow the input array a to be modified by intermediate - /// calculations, to save memory.

- /// In this case, the contents of the input - /// a after this function completes is undefined. - /// - /// - /// This optional parameter specifies the interpolation method to - /// use when the desired percentile lies between two data points - /// i < j: - /// - /// - /// If q is a single percentile and axis=None, then the result - /// is a scalar.

- /// If multiple percentiles are given, first axis of - /// the result corresponds to the percentiles.

- /// The other axes are - /// the axes that remain after the reduction of a.

- /// If the input - /// contains integers or floats smaller than float64, the output - /// data-type is float64. Otherwise, the output data-type is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public double nanpercentile(NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - q, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation); - dynamic py = __self__.InvokeMethod("nanpercentile", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the q-th quantile of the data along the specified axis.

- /// - /// ..versionadded:: 1.15.0 - /// - /// Notes - /// - /// Given a vector V of length N, the q-th quantile of - /// V is the value q of the way from the minimum to the - /// maximum in a sorted copy of V.

- /// The values and distances of - /// the two nearest neighbors as well as the interpolation parameter - /// will determine the quantile if the normalized ranking does not - /// match the location of q exactly.

- /// This function is the same as - /// the median if q=0.5, the same as the minimum if q=0.0 and the - /// same as the maximum if q=1.0. - /// - /// - /// Quantile or sequence of quantiles to compute, which must be between - /// 0 and 1 inclusive. - /// - /// - /// Axis or axes along which the quantiles are computed.

- /// The - /// default is to compute the quantile(s) along a flattened - /// version of the array. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow the input array a to be modified by intermediate - /// calculations, to save memory.

- /// In this case, the contents of the input - /// a after this function completes is undefined. - /// - /// - /// This optional parameter specifies the interpolation method to - /// use when the desired quantile lies between two data points - /// i < j: - /// - /// - /// If this is set to True, the axes which are reduced are left in - /// the result as dimensions with size one.

- /// With this option, the - /// result will broadcast correctly against the original array a. - /// - /// - /// If q is a single quantile and axis=None, then the result - /// is a scalar.

- /// If multiple quantiles are given, first axis of - /// the result corresponds to the quantiles.

- /// The other axes are - /// the axes that remain after the reduction of a.

- /// If the input - /// contains integers or floats smaller than float64, the output - /// data-type is float64. Otherwise, the output data-type is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public NDarray quantile(NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - q, - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation); - if (keepdims!=false) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("quantile", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the q-th quantile of the data along the specified axis.

- /// - /// ..versionadded:: 1.15.0 - /// - /// Notes - /// - /// Given a vector V of length N, the q-th quantile of - /// V is the value q of the way from the minimum to the - /// maximum in a sorted copy of V.

- /// The values and distances of - /// the two nearest neighbors as well as the interpolation parameter - /// will determine the quantile if the normalized ranking does not - /// match the location of q exactly.

- /// This function is the same as - /// the median if q=0.5, the same as the minimum if q=0.0 and the - /// same as the maximum if q=1.0. - /// - /// - /// Quantile or sequence of quantiles to compute, which must be between - /// 0 and 1 inclusive. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow the input array a to be modified by intermediate - /// calculations, to save memory.

- /// In this case, the contents of the input - /// a after this function completes is undefined. - /// - /// - /// This optional parameter specifies the interpolation method to - /// use when the desired quantile lies between two data points - /// i < j: - /// - /// - /// If q is a single quantile and axis=None, then the result - /// is a scalar.

- /// If multiple quantiles are given, first axis of - /// the result corresponds to the quantiles.

- /// The other axes are - /// the axes that remain after the reduction of a.

- /// If the input - /// contains integers or floats smaller than float64, the output - /// data-type is float64. Otherwise, the output data-type is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public double quantile(NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - q, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation); - dynamic py = __self__.InvokeMethod("quantile", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the qth quantile of the data along the specified axis, - /// while ignoring nan values.

- /// - /// Returns the qth quantile(s) of the array elements.

- /// - /// .. versionadded:: 1.15.0 - /// - /// - /// Quantile or sequence of quantiles to compute, which must be between - /// 0 and 1 inclusive. - /// - /// - /// Axis or axes along which the quantiles are computed.

- /// The - /// default is to compute the quantile(s) along a flattened - /// version of the array. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow the input array a to be modified by intermediate - /// calculations, to save memory.

- /// In this case, the contents of the input - /// a after this function completes is undefined. - /// - /// - /// This optional parameter specifies the interpolation method to - /// use when the desired quantile lies between two data points - /// i < j: - /// - /// - /// If this is set to True, the axes which are reduced are left in - /// the result as dimensions with size one.

- /// With this option, the - /// result will broadcast correctly against the original array a.

- /// - /// If this is anything but the default value it will be passed - /// through (in the special case of an empty array) to the - /// mean function of the underlying array.

- /// If the array is - /// a sub-class and mean does not have the kwarg keepdims this - /// will raise a RuntimeError. - /// - /// - /// If q is a single percentile and axis=None, then the result - /// is a scalar.

- /// If multiple quantiles are given, first axis of - /// the result corresponds to the quantiles.

- /// The other axes are - /// the axes that remain after the reduction of a.

- /// If the input - /// contains integers or floats smaller than float64, the output - /// data-type is float64. Otherwise, the output data-type is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public NDarray nanquantile(NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - q, - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanquantile", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the qth quantile of the data along the specified axis, - /// while ignoring nan values.

- /// - /// Returns the qth quantile(s) of the array elements.

- /// - /// .. versionadded:: 1.15.0 - /// - /// - /// Quantile or sequence of quantiles to compute, which must be between - /// 0 and 1 inclusive. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow the input array a to be modified by intermediate - /// calculations, to save memory.

- /// In this case, the contents of the input - /// a after this function completes is undefined. - /// - /// - /// This optional parameter specifies the interpolation method to - /// use when the desired quantile lies between two data points - /// i < j: - /// - /// - /// If q is a single percentile and axis=None, then the result - /// is a scalar.

- /// If multiple quantiles are given, first axis of - /// the result corresponds to the quantiles.

- /// The other axes are - /// the axes that remain after the reduction of a.

- /// If the input - /// contains integers or floats smaller than float64, the output - /// data-type is float64. Otherwise, the output data-type is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public double nanquantile(NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - q, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation); - dynamic py = __self__.InvokeMethod("nanquantile", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the median along the specified axis.

- /// - /// Returns the median of the array elements.

- /// - /// Notes - /// - /// Given a vector V of length N, the median of V is the - /// middle value of a sorted copy of V, V_sorted - i - /// e., V_sorted[(N-1)/2], when N is odd, and the average of the - /// two middle values of V_sorted when N is even. - /// - /// - /// Axis or axes along which the medians are computed.

- /// The default - /// is to compute the median along a flattened version of the array.

- /// - /// A sequence of axes is supported since version 1.9.0. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow use of memory of input array a for - /// calculations.

- /// The input array will be modified by the call to - /// median.

- /// This will save memory when you do not need to preserve - /// the contents of the input array.

- /// Treat the input as undefined, - /// but it will probably be fully or partially sorted.

- /// Default is - /// False.

- /// If overwrite_input is True and a is not already an - /// ndarray, an error will be raised. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the original arr. - /// - /// - /// A new array holding the result.

- /// If the input contains integers - /// or floats smaller than float64, then the output data-type is - /// np.float64. Otherwise, the data-type of the output is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public NDarray median(Axis axis, NDarray @out = null, bool? overwrite_input = false, bool? keepdims = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (keepdims!=false) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("median", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the median along the specified axis.

- /// - /// Returns the median of the array elements.

- /// - /// Notes - /// - /// Given a vector V of length N, the median of V is the - /// middle value of a sorted copy of V, V_sorted - i - /// e., V_sorted[(N-1)/2], when N is odd, and the average of the - /// two middle values of V_sorted when N is even. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow use of memory of input array a for - /// calculations.

- /// The input array will be modified by the call to - /// median.

- /// This will save memory when you do not need to preserve - /// the contents of the input array.

- /// Treat the input as undefined, - /// but it will probably be fully or partially sorted.

- /// Default is - /// False.

- /// If overwrite_input is True and a is not already an - /// ndarray, an error will be raised. - /// - /// - /// A new array holding the result.

- /// If the input contains integers - /// or floats smaller than float64, then the output data-type is - /// np.float64. Otherwise, the data-type of the output is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public double median(NDarray @out = null, bool? overwrite_input = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - dynamic py = __self__.InvokeMethod("median", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the weighted average along the specified axis. - /// - /// - /// Axis or axes along which to average a.

- /// The default, - /// axis=None, will average over all of the elements of the input array.

- /// - /// If axis is negative it counts from the last to the first axis.

- /// - /// If axis is a tuple of ints, averaging is performed on all of the axes - /// specified in the tuple instead of a single axis or all the axes as - /// before. - /// - /// - /// An array of weights associated with the values in a.

- /// Each value in - /// a contributes to the average according to its associated weight.

- /// - /// The weights array can either be 1-D (in which case its length must be - /// the size of a along the given axis) or of the same shape as a.

- /// - /// If weights=None, then all data in a are assumed to have a - /// weight equal to one. - /// - /// - /// Default is False.

- /// If True, the tuple (average, sum_of_weights) - /// is returned, otherwise only the average is returned.

- /// - /// If weights=None, sum_of_weights is equivalent to the number of - /// elements over which the average is taken. - /// - /// - /// Return the average along the specified axis.

- /// When returned is True, - /// return a tuple with the average as the first element and the sum - /// of the weights as the second element.

- /// sum_of_weights is of the - /// same type as retval.

- /// The result dtype follows a genereal pattern.

- /// - /// If weights is None, the result dtype will be that of a , or float64 - /// if a is integral.

- /// Otherwise, if weights is not None and a is non- - /// integral, the result type will be the type of lowest precision capable of - /// representing values of both a and weights.

- /// If a happens to be - /// integral, the previous rules still applies but the result dtype will - /// at least be float64. - /// - public NDarray average(Axis axis, NDarray weights = null, bool? returned = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (weights!=null) kwargs["weights"]=ToPython(weights); - if (returned!=false) kwargs["returned"]=ToPython(returned); - dynamic py = __self__.InvokeMethod("average", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the weighted average along the specified axis. - /// - /// - /// An array of weights associated with the values in a.

- /// Each value in - /// a contributes to the average according to its associated weight.

- /// - /// The weights array can either be 1-D (in which case its length must be - /// the size of a along the given axis) or of the same shape as a.

- /// - /// If weights=None, then all data in a are assumed to have a - /// weight equal to one. - /// - /// - /// Default is False.

- /// If True, the tuple (average, sum_of_weights) - /// is returned, otherwise only the average is returned.

- /// - /// If weights=None, sum_of_weights is equivalent to the number of - /// elements over which the average is taken. - /// - /// - /// Return the average along the specified axis.

- /// When returned is True, - /// return a tuple with the average as the first element and the sum - /// of the weights as the second element.

- /// sum_of_weights is of the - /// same type as retval.

- /// The result dtype follows a genereal pattern.

- /// - /// If weights is None, the result dtype will be that of a , or float64 - /// if a is integral.

- /// Otherwise, if weights is not None and a is non- - /// integral, the result type will be the type of lowest precision capable of - /// representing values of both a and weights.

- /// If a happens to be - /// integral, the previous rules still applies but the result dtype will - /// at least be float64. - /// - public double average(NDarray weights = null, bool? returned = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (weights!=null) kwargs["weights"]=ToPython(weights); - if (returned!=false) kwargs["returned"]=ToPython(returned); - dynamic py = __self__.InvokeMethod("average", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the arithmetic mean along the specified axis.

- /// - /// Returns the average of the array elements.

- /// The average is taken over - /// the flattened array by default, otherwise over the specified axis.

- /// - /// float64 intermediate and return values are used for integer inputs.

- /// - /// Notes - /// - /// The arithmetic mean is the sum of the elements along the axis divided - /// by the number of elements.

- /// - /// Note that for floating-point input, the mean is computed using the - /// same precision the input has.

- /// Depending on the input data, this can - /// cause the results to be inaccurate, especially for float32 (see - /// example below).

- /// Specifying a higher-precision accumulator using the - /// dtype keyword can alleviate this issue.

- /// - /// By default, float16 results are computed using float32 intermediates - /// for extra precision. - /// - /// - /// Axis or axes along which the means are computed.

- /// The default is to - /// compute the mean of the flattened array.

- /// - /// If this is a tuple of ints, a mean is performed over multiple axes, - /// instead of a single axis or all the axes as before. - /// - /// - /// Type to use in computing the mean.

- /// For integer inputs, the default - /// is float64; for floating point inputs, it is the same as the - /// input dtype. - /// - /// - /// Alternate output array in which to place the result.

- /// The default - /// is None; if provided, it must have the same shape as the - /// expected output, but the type will be cast if necessary.

- /// - /// See doc.ufuncs for details. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the input array.

- /// - /// If the default value is passed, then keepdims will not be - /// passed through to the mean method of sub-classes of - /// ndarray, however any non-default value will be.

- /// If the - /// sub-class’ method does not implement keepdims any - /// exceptions will be raised. - /// - /// - /// If out=None, returns a new array containing the mean values, - /// otherwise a reference to the output array is returned. - /// - public NDarray mean(Axis axis, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("mean", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the arithmetic mean along the specified axis.

- /// - /// Returns the average of the array elements.

- /// The average is taken over - /// the flattened array by default, otherwise over the specified axis.

- /// - /// float64 intermediate and return values are used for integer inputs.

- /// - /// Notes - /// - /// The arithmetic mean is the sum of the elements along the axis divided - /// by the number of elements.

- /// - /// Note that for floating-point input, the mean is computed using the - /// same precision the input has.

- /// Depending on the input data, this can - /// cause the results to be inaccurate, especially for float32 (see - /// example below).

- /// Specifying a higher-precision accumulator using the - /// dtype keyword can alleviate this issue.

- /// - /// By default, float16 results are computed using float32 intermediates - /// for extra precision. - /// - /// - /// Type to use in computing the mean.

- /// For integer inputs, the default - /// is float64; for floating point inputs, it is the same as the - /// input dtype. - /// - /// - /// Alternate output array in which to place the result.

- /// The default - /// is None; if provided, it must have the same shape as the - /// expected output, but the type will be cast if necessary.

- /// - /// See doc.ufuncs for details. - /// - /// - /// If out=None, returns a new array containing the mean values, - /// otherwise a reference to the output array is returned. - /// - public double mean(Dtype dtype = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("mean", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the standard deviation along the specified axis.

- /// - /// Returns the standard deviation, a measure of the spread of a distribution, - /// of the array elements.

- /// The standard deviation is computed for the - /// flattened array by default, otherwise over the specified axis.

- /// - /// Notes - /// - /// The standard deviation is the square root of the average of the squared - /// deviations from the mean, i.e., std = sqrt(mean(abs(x - x.mean())**2)).

- /// - /// The average squared deviation is normally calculated as - /// x.sum() / N, where N = len(x).

- /// If, however, ddof is specified, - /// the divisor N - ddof is used instead.

- /// In standard statistical - /// practice, ddof=1 provides an unbiased estimator of the variance - /// of the infinite population.

- /// ddof=0 provides a maximum likelihood - /// estimate of the variance for normally distributed variables.

- /// The - /// standard deviation computed in this function is the square root of - /// the estimated variance, so even with ddof=1, it will not be an - /// unbiased estimate of the standard deviation per se.

- /// - /// Note that, for complex numbers, std takes the absolute - /// value before squaring, so that the result is always real and nonnegative.

- /// - /// For floating-point input, the std is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32 (see example below).

- /// - /// Specifying a higher-accuracy accumulator using the dtype keyword can - /// alleviate this issue. - /// - /// - /// Axis or axes along which the standard deviation is computed.

- /// The - /// default is to compute the standard deviation of the flattened array.

- /// - /// If this is a tuple of ints, a standard deviation is performed over - /// multiple axes, instead of a single axis or all the axes as before. - /// - /// - /// Type to use in computing the standard deviation.

- /// For arrays of - /// integer type the default is float64, for arrays of float types it is - /// the same as the array type. - /// - /// - /// Alternative output array in which to place the result.

- /// It must have - /// the same shape as the expected output but the type (of the calculated - /// values) will be cast if necessary. - /// - /// - /// Means Delta Degrees of Freedom.

- /// The divisor used in calculations - /// is N - ddof, where N represents the number of elements.

- /// - /// By default ddof is zero. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the input array.

- /// - /// If the default value is passed, then keepdims will not be - /// passed through to the std method of sub-classes of - /// ndarray, however any non-default value will be.

- /// If the - /// sub-class’ method does not implement keepdims any - /// exceptions will be raised. - /// - /// - /// If out is None, return a new array containing the standard deviation, - /// otherwise return a reference to the output array. - /// - public NDarray std(Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (ddof!=0) kwargs["ddof"]=ToPython(ddof); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("std", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the standard deviation along the specified axis.

- /// - /// Returns the standard deviation, a measure of the spread of a distribution, - /// of the array elements.

- /// The standard deviation is computed for the - /// flattened array by default, otherwise over the specified axis.

- /// - /// Notes - /// - /// The standard deviation is the square root of the average of the squared - /// deviations from the mean, i.e., std = sqrt(mean(abs(x - x.mean())**2)).

- /// - /// The average squared deviation is normally calculated as - /// x.sum() / N, where N = len(x).

- /// If, however, ddof is specified, - /// the divisor N - ddof is used instead.

- /// In standard statistical - /// practice, ddof=1 provides an unbiased estimator of the variance - /// of the infinite population.

- /// ddof=0 provides a maximum likelihood - /// estimate of the variance for normally distributed variables.

- /// The - /// standard deviation computed in this function is the square root of - /// the estimated variance, so even with ddof=1, it will not be an - /// unbiased estimate of the standard deviation per se.

- /// - /// Note that, for complex numbers, std takes the absolute - /// value before squaring, so that the result is always real and nonnegative.

- /// - /// For floating-point input, the std is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32 (see example below).

- /// - /// Specifying a higher-accuracy accumulator using the dtype keyword can - /// alleviate this issue. - /// - /// - /// Type to use in computing the standard deviation.

- /// For arrays of - /// integer type the default is float64, for arrays of float types it is - /// the same as the array type. - /// - /// - /// Alternative output array in which to place the result.

- /// It must have - /// the same shape as the expected output but the type (of the calculated - /// values) will be cast if necessary. - /// - /// - /// Means Delta Degrees of Freedom.

- /// The divisor used in calculations - /// is N - ddof, where N represents the number of elements.

- /// - /// By default ddof is zero. - /// - /// - /// If out is None, return a new array containing the standard deviation, - /// otherwise return a reference to the output array. - /// - public double std(Dtype dtype = null, NDarray @out = null, int? ddof = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (ddof!=0) kwargs["ddof"]=ToPython(ddof); - dynamic py = __self__.InvokeMethod("std", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the variance along the specified axis.

- /// - /// Returns the variance of the array elements, a measure of the spread of a - /// distribution.

- /// The variance is computed for the flattened array by - /// default, otherwise over the specified axis.

- /// - /// Notes - /// - /// The variance is the average of the squared deviations from the mean, - /// i.e., var = mean(abs(x - x.mean())**2).

- /// - /// The mean is normally calculated as x.sum() / N, where N = len(x).

- /// - /// If, however, ddof is specified, the divisor N - ddof is used - /// instead.

- /// In standard statistical practice, ddof=1 provides an - /// unbiased estimator of the variance of a hypothetical infinite population.

- /// - /// ddof=0 provides a maximum likelihood estimate of the variance for - /// normally distributed variables.

- /// - /// Note that for complex numbers, the absolute value is taken before - /// squaring, so that the result is always real and nonnegative.

- /// - /// For floating-point input, the variance is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32 (see example - /// below).

- /// Specifying a higher-accuracy accumulator using the dtype - /// keyword can alleviate this issue. - /// - /// - /// Axis or axes along which the variance is computed.

- /// The default is to - /// compute the variance of the flattened array.

- /// - /// If this is a tuple of ints, a variance is performed over multiple axes, - /// instead of a single axis or all the axes as before. - /// - /// - /// Type to use in computing the variance.

- /// For arrays of integer type - /// the default is float32; for arrays of float types it is the same as - /// the array type. - /// - /// - /// Alternate output array in which to place the result.

- /// It must have - /// the same shape as the expected output, but the type is cast if - /// necessary. - /// - /// - /// “Delta Degrees of Freedom”: the divisor used in the calculation is - /// N - ddof, where N represents the number of elements.

- /// By - /// default ddof is zero. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the input array.

- /// - /// If the default value is passed, then keepdims will not be - /// passed through to the var method of sub-classes of - /// ndarray, however any non-default value will be.

- /// If the - /// sub-class’ method does not implement keepdims any - /// exceptions will be raised. - /// - /// - /// If out=None, returns a new array containing the variance; - /// otherwise, a reference to the output array is returned. - /// - public NDarray @var(Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (ddof!=0) kwargs["ddof"]=ToPython(ddof); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("var", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the variance along the specified axis.

- /// - /// Returns the variance of the array elements, a measure of the spread of a - /// distribution.

- /// The variance is computed for the flattened array by - /// default, otherwise over the specified axis.

- /// - /// Notes - /// - /// The variance is the average of the squared deviations from the mean, - /// i.e., var = mean(abs(x - x.mean())**2).

- /// - /// The mean is normally calculated as x.sum() / N, where N = len(x).

- /// - /// If, however, ddof is specified, the divisor N - ddof is used - /// instead.

- /// In standard statistical practice, ddof=1 provides an - /// unbiased estimator of the variance of a hypothetical infinite population.

- /// - /// ddof=0 provides a maximum likelihood estimate of the variance for - /// normally distributed variables.

- /// - /// Note that for complex numbers, the absolute value is taken before - /// squaring, so that the result is always real and nonnegative.

- /// - /// For floating-point input, the variance is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32 (see example - /// below).

- /// Specifying a higher-accuracy accumulator using the dtype - /// keyword can alleviate this issue. - /// - /// - /// Type to use in computing the variance.

- /// For arrays of integer type - /// the default is float32; for arrays of float types it is the same as - /// the array type. - /// - /// - /// Alternate output array in which to place the result.

- /// It must have - /// the same shape as the expected output, but the type is cast if - /// necessary. - /// - /// - /// “Delta Degrees of Freedom”: the divisor used in the calculation is - /// N - ddof, where N represents the number of elements.

- /// By - /// default ddof is zero. - /// - /// - /// If out=None, returns a new array containing the variance; - /// otherwise, a reference to the output array is returned. - /// - public double @var(Dtype dtype = null, NDarray @out = null, int? ddof = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (ddof!=0) kwargs["ddof"]=ToPython(ddof); - dynamic py = __self__.InvokeMethod("var", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the median along the specified axis, while ignoring NaNs.

- /// - /// Returns the median of the array elements.

- /// - /// Notes - /// - /// Given a vector V of length N, the median of V is the - /// middle value of a sorted copy of V, V_sorted - i.e., - /// V_sorted[(N-1)/2], when N is odd and the average of the two - /// middle values of V_sorted when N is even. - /// - /// - /// Axis or axes along which the medians are computed.

- /// The default - /// is to compute the median along a flattened version of the array.

- /// - /// A sequence of axes is supported since version 1.9.0. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow use of memory of input array a for - /// calculations.

- /// The input array will be modified by the call to - /// median.

- /// This will save memory when you do not need to preserve - /// the contents of the input array.

- /// Treat the input as undefined, - /// but it will probably be fully or partially sorted.

- /// Default is - /// False.

- /// If overwrite_input is True and a is not already an - /// ndarray, an error will be raised. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the original a.

- /// - /// If this is anything but the default value it will be passed - /// through (in the special case of an empty array) to the - /// mean function of the underlying array.

- /// If the array is - /// a sub-class and mean does not have the kwarg keepdims this - /// will raise a RuntimeError. - /// - /// - /// A new array holding the result.

- /// If the input contains integers - /// or floats smaller than float64, then the output data-type is - /// np.float64. Otherwise, the data-type of the output is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public NDarray nanmedian(Axis axis, NDarray @out = null, bool? overwrite_input = false, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanmedian", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the median along the specified axis, while ignoring NaNs.

- /// - /// Returns the median of the array elements.

- /// - /// Notes - /// - /// Given a vector V of length N, the median of V is the - /// middle value of a sorted copy of V, V_sorted - i.e., - /// V_sorted[(N-1)/2], when N is odd and the average of the two - /// middle values of V_sorted when N is even. - /// - /// - /// Alternative output array in which to place the result.

- /// It must - /// have the same shape and buffer length as the expected output, - /// but the type (of the output) will be cast if necessary. - /// - /// - /// If True, then allow use of memory of input array a for - /// calculations.

- /// The input array will be modified by the call to - /// median.

- /// This will save memory when you do not need to preserve - /// the contents of the input array.

- /// Treat the input as undefined, - /// but it will probably be fully or partially sorted.

- /// Default is - /// False.

- /// If overwrite_input is True and a is not already an - /// ndarray, an error will be raised. - /// - /// - /// A new array holding the result.

- /// If the input contains integers - /// or floats smaller than float64, then the output data-type is - /// np.float64. Otherwise, the data-type of the output is the - /// same as that of the input.

- /// If out is specified, that array is - /// returned instead. - /// - public double nanmedian(NDarray @out = null, bool? overwrite_input = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input); - dynamic py = __self__.InvokeMethod("nanmedian", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the arithmetic mean along the specified axis, ignoring NaNs.

- /// - /// Returns the average of the array elements.

- /// The average is taken over - /// the flattened array by default, otherwise over the specified axis.

- /// - /// float64 intermediate and return values are used for integer inputs.

- /// - /// For all-NaN slices, NaN is returned and a RuntimeWarning is raised.

- /// - /// Notes - /// - /// The arithmetic mean is the sum of the non-NaN elements along the axis - /// divided by the number of non-NaN elements.

- /// - /// Note that for floating-point input, the mean is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32. Specifying a - /// higher-precision accumulator using the dtype keyword can alleviate - /// this issue. - /// - /// - /// Axis or axes along which the means are computed.

- /// The default is to compute - /// the mean of the flattened array. - /// - /// - /// Type to use in computing the mean.

- /// For integer inputs, the default - /// is float64; for inexact inputs, it is the same as the input - /// dtype. - /// - /// - /// Alternate output array in which to place the result.

- /// The default - /// is None; if provided, it must have the same shape as the - /// expected output, but the type will be cast if necessary.

- /// See - /// doc.ufuncs for details. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the original a.

- /// - /// If the value is anything but the default, then - /// keepdims will be passed through to the mean or sum methods - /// of sub-classes of ndarray.

- /// If the sub-classes methods - /// does not implement keepdims any exceptions will be raised. - /// - /// - /// If out=None, returns a new array containing the mean values, - /// otherwise a reference to the output array is returned.

- /// Nan is - /// returned for slices that contain only NaNs. - /// - public NDarray nanmean(Axis axis, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanmean", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the arithmetic mean along the specified axis, ignoring NaNs.

- /// - /// Returns the average of the array elements.

- /// The average is taken over - /// the flattened array by default, otherwise over the specified axis.

- /// - /// float64 intermediate and return values are used for integer inputs.

- /// - /// For all-NaN slices, NaN is returned and a RuntimeWarning is raised.

- /// - /// Notes - /// - /// The arithmetic mean is the sum of the non-NaN elements along the axis - /// divided by the number of non-NaN elements.

- /// - /// Note that for floating-point input, the mean is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32. Specifying a - /// higher-precision accumulator using the dtype keyword can alleviate - /// this issue. - /// - /// - /// Type to use in computing the mean.

- /// For integer inputs, the default - /// is float64; for inexact inputs, it is the same as the input - /// dtype. - /// - /// - /// Alternate output array in which to place the result.

- /// The default - /// is None; if provided, it must have the same shape as the - /// expected output, but the type will be cast if necessary.

- /// See - /// doc.ufuncs for details. - /// - /// - /// If out=None, returns a new array containing the mean values, - /// otherwise a reference to the output array is returned.

- /// Nan is - /// returned for slices that contain only NaNs. - /// - public double nanmean(Dtype dtype = null, NDarray @out = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - dynamic py = __self__.InvokeMethod("nanmean", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the standard deviation along the specified axis, while - /// ignoring NaNs.

- /// - /// Returns the standard deviation, a measure of the spread of a - /// distribution, of the non-NaN array elements.

- /// The standard deviation is - /// computed for the flattened array by default, otherwise over the - /// specified axis.

- /// - /// For all-NaN slices or slices with zero degrees of freedom, NaN is - /// returned and a RuntimeWarning is raised.

- /// - /// Notes - /// - /// The standard deviation is the square root of the average of the squared - /// deviations from the mean: std = sqrt(mean(abs(x - x.mean())**2)).

- /// - /// The average squared deviation is normally calculated as - /// x.sum() / N, where N = len(x).

- /// If, however, ddof is - /// specified, the divisor N - ddof is used instead.

- /// In standard - /// statistical practice, ddof=1 provides an unbiased estimator of the - /// variance of the infinite population.

- /// ddof=0 provides a maximum - /// likelihood estimate of the variance for normally distributed variables.

- /// - /// The standard deviation computed in this function is the square root of - /// the estimated variance, so even with ddof=1, it will not be an - /// unbiased estimate of the standard deviation per se.

- /// - /// Note that, for complex numbers, std takes the absolute value before - /// squaring, so that the result is always real and nonnegative.

- /// - /// For floating-point input, the std is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32 (see example - /// below).

- /// Specifying a higher-accuracy accumulator using the dtype - /// keyword can alleviate this issue. - /// - /// - /// Axis or axes along which the standard deviation is computed.

- /// The default is - /// to compute the standard deviation of the flattened array. - /// - /// - /// Type to use in computing the standard deviation.

- /// For arrays of - /// integer type the default is float64, for arrays of float types it - /// is the same as the array type. - /// - /// - /// Alternative output array in which to place the result.

- /// It must have - /// the same shape as the expected output but the type (of the - /// calculated values) will be cast if necessary. - /// - /// - /// Means Delta Degrees of Freedom.

- /// The divisor used in calculations - /// is N - ddof, where N represents the number of non-NaN - /// elements.

- /// By default ddof is zero. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the original a.

- /// - /// If this value is anything but the default it is passed through - /// as-is to the relevant functions of the sub-classes.

- /// If these - /// functions do not have a keepdims kwarg, a RuntimeError will - /// be raised. - /// - /// - /// If out is None, return a new array containing the standard - /// deviation, otherwise return a reference to the output array.

- /// If - /// ddof is >= the number of non-NaN elements in a slice or the slice - /// contains only NaNs, then the result for that slice is NaN. - /// - public NDarray nanstd(Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (ddof!=0) kwargs["ddof"]=ToPython(ddof); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanstd", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the standard deviation along the specified axis, while - /// ignoring NaNs.

- /// - /// Returns the standard deviation, a measure of the spread of a - /// distribution, of the non-NaN array elements.

- /// The standard deviation is - /// computed for the flattened array by default, otherwise over the - /// specified axis.

- /// - /// For all-NaN slices or slices with zero degrees of freedom, NaN is - /// returned and a RuntimeWarning is raised.

- /// - /// Notes - /// - /// The standard deviation is the square root of the average of the squared - /// deviations from the mean: std = sqrt(mean(abs(x - x.mean())**2)).

- /// - /// The average squared deviation is normally calculated as - /// x.sum() / N, where N = len(x).

- /// If, however, ddof is - /// specified, the divisor N - ddof is used instead.

- /// In standard - /// statistical practice, ddof=1 provides an unbiased estimator of the - /// variance of the infinite population.

- /// ddof=0 provides a maximum - /// likelihood estimate of the variance for normally distributed variables.

- /// - /// The standard deviation computed in this function is the square root of - /// the estimated variance, so even with ddof=1, it will not be an - /// unbiased estimate of the standard deviation per se.

- /// - /// Note that, for complex numbers, std takes the absolute value before - /// squaring, so that the result is always real and nonnegative.

- /// - /// For floating-point input, the std is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32 (see example - /// below).

- /// Specifying a higher-accuracy accumulator using the dtype - /// keyword can alleviate this issue. - /// - /// - /// Type to use in computing the standard deviation.

- /// For arrays of - /// integer type the default is float64, for arrays of float types it - /// is the same as the array type. - /// - /// - /// Alternative output array in which to place the result.

- /// It must have - /// the same shape as the expected output but the type (of the - /// calculated values) will be cast if necessary. - /// - /// - /// Means Delta Degrees of Freedom.

- /// The divisor used in calculations - /// is N - ddof, where N represents the number of non-NaN - /// elements.

- /// By default ddof is zero. - /// - /// - /// If out is None, return a new array containing the standard - /// deviation, otherwise return a reference to the output array.

- /// If - /// ddof is >= the number of non-NaN elements in a slice or the slice - /// contains only NaNs, then the result for that slice is NaN. - /// - public double nanstd(Dtype dtype = null, NDarray @out = null, int? ddof = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (ddof!=0) kwargs["ddof"]=ToPython(ddof); - dynamic py = __self__.InvokeMethod("nanstd", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the variance along the specified axis, while ignoring NaNs.

- /// - /// Returns the variance of the array elements, a measure of the spread of - /// a distribution.

- /// The variance is computed for the flattened array by - /// default, otherwise over the specified axis.

- /// - /// For all-NaN slices or slices with zero degrees of freedom, NaN is - /// returned and a RuntimeWarning is raised.

- /// - /// Notes - /// - /// The variance is the average of the squared deviations from the mean, - /// i.e., var = mean(abs(x - x.mean())**2).

- /// - /// The mean is normally calculated as x.sum() / N, where N = len(x).

- /// - /// If, however, ddof is specified, the divisor N - ddof is used - /// instead.

- /// In standard statistical practice, ddof=1 provides an - /// unbiased estimator of the variance of a hypothetical infinite - /// population.

- /// ddof=0 provides a maximum likelihood estimate of the - /// variance for normally distributed variables.

- /// - /// Note that for complex numbers, the absolute value is taken before - /// squaring, so that the result is always real and nonnegative.

- /// - /// For floating-point input, the variance is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32 (see example - /// below).

- /// Specifying a higher-accuracy accumulator using the dtype - /// keyword can alleviate this issue.

- /// - /// For this function to work on sub-classes of ndarray, they must define - /// sum with the kwarg keepdims - /// - /// - /// Axis or axes along which the variance is computed.

- /// The default is to compute - /// the variance of the flattened array. - /// - /// - /// Type to use in computing the variance.

- /// For arrays of integer type - /// the default is float32; for arrays of float types it is the same as - /// the array type. - /// - /// - /// Alternate output array in which to place the result.

- /// It must have - /// the same shape as the expected output, but the type is cast if - /// necessary. - /// - /// - /// “Delta Degrees of Freedom”: the divisor used in the calculation is - /// N - ddof, where N represents the number of non-NaN - /// elements.

- /// By default ddof is zero. - /// - /// - /// If this is set to True, the axes which are reduced are left - /// in the result as dimensions with size one.

- /// With this option, - /// the result will broadcast correctly against the original a. - /// - /// - /// If out is None, return a new array containing the variance, - /// otherwise return a reference to the output array.

- /// If ddof is >= the - /// number of non-NaN elements in a slice or the slice contains only - /// NaNs, then the result for that slice is NaN. - /// - public NDarray nanvar(Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (axis!=null) kwargs["axis"]=ToPython(axis); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (ddof!=0) kwargs["ddof"]=ToPython(ddof); - if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims); - dynamic py = __self__.InvokeMethod("nanvar", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Compute the variance along the specified axis, while ignoring NaNs.

- /// - /// Returns the variance of the array elements, a measure of the spread of - /// a distribution.

- /// The variance is computed for the flattened array by - /// default, otherwise over the specified axis.

- /// - /// For all-NaN slices or slices with zero degrees of freedom, NaN is - /// returned and a RuntimeWarning is raised.

- /// - /// Notes - /// - /// The variance is the average of the squared deviations from the mean, - /// i.e., var = mean(abs(x - x.mean())**2).

- /// - /// The mean is normally calculated as x.sum() / N, where N = len(x).

- /// - /// If, however, ddof is specified, the divisor N - ddof is used - /// instead.

- /// In standard statistical practice, ddof=1 provides an - /// unbiased estimator of the variance of a hypothetical infinite - /// population.

- /// ddof=0 provides a maximum likelihood estimate of the - /// variance for normally distributed variables.

- /// - /// Note that for complex numbers, the absolute value is taken before - /// squaring, so that the result is always real and nonnegative.

- /// - /// For floating-point input, the variance is computed using the same - /// precision the input has.

- /// Depending on the input data, this can cause - /// the results to be inaccurate, especially for float32 (see example - /// below).

- /// Specifying a higher-accuracy accumulator using the dtype - /// keyword can alleviate this issue.

- /// - /// For this function to work on sub-classes of ndarray, they must define - /// sum with the kwarg keepdims - /// - /// - /// Type to use in computing the variance.

- /// For arrays of integer type - /// the default is float32; for arrays of float types it is the same as - /// the array type. - /// - /// - /// Alternate output array in which to place the result.

- /// It must have - /// the same shape as the expected output, but the type is cast if - /// necessary. - /// - /// - /// “Delta Degrees of Freedom”: the divisor used in the calculation is - /// N - ddof, where N represents the number of non-NaN - /// elements.

- /// By default ddof is zero. - /// - /// - /// If out is None, return a new array containing the variance, - /// otherwise return a reference to the output array.

- /// If ddof is >= the - /// number of non-NaN elements in a slice or the slice contains only - /// NaNs, then the result for that slice is NaN. - /// - public double nanvar(Dtype dtype = null, NDarray @out = null, int? ddof = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (ddof!=0) kwargs["ddof"]=ToPython(ddof); - dynamic py = __self__.InvokeMethod("nanvar", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Return Pearson product-moment correlation coefficients.

- /// - /// Please refer to the documentation for cov for more detail.

- /// The - /// relationship between the correlation coefficient matrix, R, and the - /// covariance matrix, C, is - /// - /// The values of R are between -1 and 1, inclusive.

- /// - /// Notes - /// - /// Due to floating point rounding the resulting array may not be Hermitian, - /// the diagonal elements may not be 1, and the elements may not satisfy the - /// inequality abs(a) <= 1.

- /// The real and imaginary parts are clipped to the - /// interval [-1, 1] in an attempt to improve on that situation but is not - /// much help in the complex case.

- /// - /// This function accepts but discards arguments bias and ddof.

- /// This is - /// for backwards compatibility with previous versions of this function.

- /// These - /// arguments had no effect on the return values of the function and can be - /// safely ignored in this and previous versions of numpy. - /// - /// - /// An additional set of variables and observations.

- /// y has the same - /// shape as x. - /// - /// - /// If rowvar is True (default), then each row represents a - /// variable, with observations in the columns.

- /// Otherwise, the relationship - /// is transposed: each column represents a variable, while the rows - /// contain observations. - /// - /// - /// The correlation coefficient matrix of the variables. - /// - public NDarray corrcoef(NDarray y = null, bool? rowvar = true) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (y!=null) kwargs["y"]=ToPython(y); - if (rowvar!=true) kwargs["rowvar"]=ToPython(rowvar); - dynamic py = __self__.InvokeMethod("corrcoef", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Cross-correlation of two 1-dimensional sequences.

- /// - /// This function computes the correlation as generally defined in signal - /// processing texts: - /// - /// with a and v sequences being zero-padded where necessary and conj being - /// the conjugate.

- /// - /// Notes - /// - /// The definition of correlation above is not unique and sometimes correlation - /// may be defined differently.

- /// Another common definition is: - /// - /// which is related to c_{av}[k] by c'_{av}[k] = c_{av}[-k]. - /// - /// - /// Input sequences. - /// - /// - /// Refer to the convolve docstring.

- /// Note that the default - /// is ‘valid’, unlike convolve, which uses ‘full’. - /// - /// - /// Discrete cross-correlation of a and v. - /// - public NDarray correlate(NDarray a, string mode = "valid") - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - a, - }); - var kwargs=new PyDict(); - if (mode!="valid") kwargs["mode"]=ToPython(mode); - dynamic py = __self__.InvokeMethod("correlate", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Estimate a covariance matrix, given data and weights.

- /// - /// Covariance indicates the level to which two variables vary together.

- /// - /// If we examine N-dimensional samples, , - /// then the covariance matrix element is the covariance of - /// and . The element is the variance - /// of . - /// - /// See the notes for an outline of the algorithm.

- /// - /// Notes - /// - /// Assume that the observations are in the columns of the observation - /// array m and let f = fweights and a = aweights for brevity.

- /// The - /// steps to compute the weighted covariance are as follows: - /// - /// Note that when a == 1, the normalization factor - /// v1 / (v1**2 - ddof * v2) goes over to 1 / (np.sum(f) - ddof) - /// as it should. - /// - /// - /// An additional set of variables and observations.

- /// y has the same form - /// as that of m. - /// - /// - /// If rowvar is True (default), then each row represents a - /// variable, with observations in the columns.

- /// Otherwise, the relationship - /// is transposed: each column represents a variable, while the rows - /// contain observations. - /// - /// - /// Default normalization (False) is by (N - 1), where N is the - /// number of observations given (unbiased estimate).

- /// If bias is True, - /// then normalization is by N.

- /// These values can be overridden by using - /// the keyword ddof in numpy versions >= 1.5. - /// - /// - /// If not None the default value implied by bias is overridden.

- /// - /// Note that ddof=1 will return the unbiased estimate, even if both - /// fweights and aweights are specified, and ddof=0 will return - /// the simple average.

- /// See the notes for the details.

- /// The default value - /// is None. - /// - /// - /// 1-D array of integer frequency weights; the number of times each - /// observation vector should be repeated. - /// - /// - /// 1-D array of observation vector weights.

- /// These relative weights are - /// typically large for observations considered “important” and smaller for - /// observations considered less “important”. If ddof=0 the array of - /// weights can be used to assign probabilities to observation vectors. - /// - /// - /// The covariance matrix of the variables. - /// - public NDarray cov(NDarray y = null, bool? rowvar = true, bool? bias = false, int? ddof = null, NDarray fweights = null, NDarray aweights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (y!=null) kwargs["y"]=ToPython(y); - if (rowvar!=true) kwargs["rowvar"]=ToPython(rowvar); - if (bias!=false) kwargs["bias"]=ToPython(bias); - if (ddof!=null) kwargs["ddof"]=ToPython(ddof); - if (fweights!=null) kwargs["fweights"]=ToPython(fweights); - if (aweights!=null) kwargs["aweights"]=ToPython(aweights); - dynamic py = __self__.InvokeMethod("cov", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Compute the histogram of a set of data.

- /// - /// Notes - /// - /// All but the last (righthand-most) bin is half-open.

- /// In other words, - /// if bins is: - /// - /// then the first bin is [1, 2) (including 1, but excluding 2) and - /// the second [2, 3).

- /// The last bin, however, is [3, 4], which - /// includes 4. - /// - /// - /// If bins is an int, it defines the number of equal-width - /// bins in the given range (10, by default).

- /// If bins is a - /// sequence, it defines a monotonically increasing array of bin edges, - /// including the rightmost edge, allowing for non-uniform bin widths.

- /// - /// If bins is a string, it defines the method used to calculate the - /// optimal bin width, as defined by histogram_bin_edges. - /// - /// - /// The lower and upper range of the bins.

- /// If not provided, range - /// is simply (a.min(), a.max()).

- /// Values outside the range are - /// ignored.

- /// The first element of the range must be less than or - /// equal to the second.

- /// range affects the automatic bin - /// computation as well.

- /// While bin width is computed to be optimal - /// based on the actual data within range, the bin count will fill - /// the entire range including portions containing no data. - /// - /// - /// This is equivalent to the density argument, but produces incorrect - /// results for unequal bin widths.

- /// It should not be used. - /// - /// - /// An array of weights, of the same shape as a.

- /// Each value in - /// a only contributes its associated weight towards the bin count - /// (instead of 1).

- /// If density is True, the weights are - /// normalized, so that the integral of the density over the range - /// remains 1. - /// - /// - /// If False, the result will contain the number of samples in - /// each bin.

- /// If True, the result is the value of the - /// probability density function at the bin, normalized such that - /// the integral over the range is 1.

- /// Note that the sum of the - /// histogram values will not be equal to 1 unless bins of unity - /// width are chosen; it is not a probability mass function.

- /// - /// Overrides the normed keyword if given. - /// - /// - /// A tuple of: - /// hist - /// The values of the histogram. See density and weights for a - /// description of the possible semantics. - /// bin_edges - /// Return the bin edges (length(hist)+1). - /// - public (NDarray, NDarray) histogram(int? bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - if (density!=null) kwargs["density"]=ToPython(density); - dynamic py = __self__.InvokeMethod("histogram", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Compute the histogram of a set of data.

- /// - /// Notes - /// - /// All but the last (righthand-most) bin is half-open.

- /// In other words, - /// if bins is: - /// - /// then the first bin is [1, 2) (including 1, but excluding 2) and - /// the second [2, 3).

- /// The last bin, however, is [3, 4], which - /// includes 4. - /// - /// - /// If bins is an int, it defines the number of equal-width - /// bins in the given range (10, by default).

- /// If bins is a - /// sequence, it defines a monotonically increasing array of bin edges, - /// including the rightmost edge, allowing for non-uniform bin widths.

- /// - /// If bins is a string, it defines the method used to calculate the - /// optimal bin width, as defined by histogram_bin_edges. - /// - /// - /// The lower and upper range of the bins.

- /// If not provided, range - /// is simply (a.min(), a.max()).

- /// Values outside the range are - /// ignored.

- /// The first element of the range must be less than or - /// equal to the second.

- /// range affects the automatic bin - /// computation as well.

- /// While bin width is computed to be optimal - /// based on the actual data within range, the bin count will fill - /// the entire range including portions containing no data. - /// - /// - /// This is equivalent to the density argument, but produces incorrect - /// results for unequal bin widths.

- /// It should not be used. - /// - /// - /// An array of weights, of the same shape as a.

- /// Each value in - /// a only contributes its associated weight towards the bin count - /// (instead of 1).

- /// If density is True, the weights are - /// normalized, so that the integral of the density over the range - /// remains 1. - /// - /// - /// If False, the result will contain the number of samples in - /// each bin.

- /// If True, the result is the value of the - /// probability density function at the bin, normalized such that - /// the integral over the range is 1.

- /// Note that the sum of the - /// histogram values will not be equal to 1 unless bins of unity - /// width are chosen; it is not a probability mass function.

- /// - /// Overrides the normed keyword if given. - /// - /// - /// A tuple of: - /// hist - /// The values of the histogram. See density and weights for a - /// description of the possible semantics. - /// bin_edges - /// Return the bin edges (length(hist)+1). - /// - public (NDarray, NDarray) histogram(NDarray bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - if (density!=null) kwargs["density"]=ToPython(density); - dynamic py = __self__.InvokeMethod("histogram", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Compute the histogram of a set of data.

- /// - /// Notes - /// - /// All but the last (righthand-most) bin is half-open.

- /// In other words, - /// if bins is: - /// - /// then the first bin is [1, 2) (including 1, but excluding 2) and - /// the second [2, 3).

- /// The last bin, however, is [3, 4], which - /// includes 4. - /// - /// - /// If bins is an int, it defines the number of equal-width - /// bins in the given range (10, by default).

- /// If bins is a - /// sequence, it defines a monotonically increasing array of bin edges, - /// including the rightmost edge, allowing for non-uniform bin widths.

- /// - /// If bins is a string, it defines the method used to calculate the - /// optimal bin width, as defined by histogram_bin_edges. - /// - /// - /// The lower and upper range of the bins.

- /// If not provided, range - /// is simply (a.min(), a.max()).

- /// Values outside the range are - /// ignored.

- /// The first element of the range must be less than or - /// equal to the second.

- /// range affects the automatic bin - /// computation as well.

- /// While bin width is computed to be optimal - /// based on the actual data within range, the bin count will fill - /// the entire range including portions containing no data. - /// - /// - /// This is equivalent to the density argument, but produces incorrect - /// results for unequal bin widths.

- /// It should not be used. - /// - /// - /// An array of weights, of the same shape as a.

- /// Each value in - /// a only contributes its associated weight towards the bin count - /// (instead of 1).

- /// If density is True, the weights are - /// normalized, so that the integral of the density over the range - /// remains 1. - /// - /// - /// If False, the result will contain the number of samples in - /// each bin.

- /// If True, the result is the value of the - /// probability density function at the bin, normalized such that - /// the integral over the range is 1.

- /// Note that the sum of the - /// histogram values will not be equal to 1 unless bins of unity - /// width are chosen; it is not a probability mass function.

- /// - /// Overrides the normed keyword if given. - /// - /// - /// A tuple of: - /// hist - /// The values of the histogram. See density and weights for a - /// description of the possible semantics. - /// bin_edges - /// Return the bin edges (length(hist)+1). - /// - public (NDarray, NDarray) histogram(List bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - if (density!=null) kwargs["density"]=ToPython(density); - dynamic py = __self__.InvokeMethod("histogram", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Compute the bi-dimensional histogram of two data samples.

- /// - /// Notes - /// - /// When normed is True, then the returned histogram is the sample - /// density, defined such that the sum over bins of the product - /// bin_value * bin_area is 1.

- /// - /// Please note that the histogram does not follow the Cartesian convention - /// where x values are on the abscissa and y values on the ordinate - /// axis.

- /// Rather, x is histogrammed along the first dimension of the - /// array (vertical), and y along the second dimension of the array - /// (horizontal).

- /// This ensures compatibility with histogramdd. - /// - /// - /// An array containing the y coordinates of the points to be - /// histogrammed. - /// - /// - /// The bin specification: - /// - /// - /// The leftmost and rightmost edges of the bins along each dimension - /// (if not specified explicitly in the bins parameters): - /// [[xmin, xmax], [ymin, ymax]].

- /// All values outside of this range - /// will be considered outliers and not tallied in the histogram. - /// - /// - /// If False, the default, returns the number of samples in each bin.

- /// - /// If True, returns the probability density function at the bin, - /// bin_count / sample_count / bin_area. - /// - /// - /// An alias for the density argument that behaves identically.

- /// To avoid - /// confusion with the broken normed argument to histogram, density - /// should be preferred. - /// - /// - /// An array of values w_i weighing each sample (x_i, y_i).

- /// - /// Weights are normalized to 1 if normed is True.

- /// If normed is - /// False, the values of the returned histogram are equal to the sum of - /// the weights belonging to the samples falling into each bin. - /// - /// - /// A tuple of: - /// H - /// The bi-dimensional histogram of samples x and y. Values in x - /// are histogrammed along the first dimension and values in y are - /// histogrammed along the second dimension. - /// xedges - /// The bin edges along the first dimension. - /// yedges - /// The bin edges along the second dimension. - /// - public (NDarray, NDarray, NDarray) histogram2d(NDarray y, int? bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - y, - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (density!=null) kwargs["density"]=ToPython(density); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogram2d", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1]), ToCsharp(py[2])); - } - - /// - /// Compute the bi-dimensional histogram of two data samples.

- /// - /// Notes - /// - /// When normed is True, then the returned histogram is the sample - /// density, defined such that the sum over bins of the product - /// bin_value * bin_area is 1.

- /// - /// Please note that the histogram does not follow the Cartesian convention - /// where x values are on the abscissa and y values on the ordinate - /// axis.

- /// Rather, x is histogrammed along the first dimension of the - /// array (vertical), and y along the second dimension of the array - /// (horizontal).

- /// This ensures compatibility with histogramdd. - /// - /// - /// An array containing the y coordinates of the points to be - /// histogrammed. - /// - /// - /// The bin specification: - /// - /// - /// The leftmost and rightmost edges of the bins along each dimension - /// (if not specified explicitly in the bins parameters): - /// [[xmin, xmax], [ymin, ymax]].

- /// All values outside of this range - /// will be considered outliers and not tallied in the histogram. - /// - /// - /// If False, the default, returns the number of samples in each bin.

- /// - /// If True, returns the probability density function at the bin, - /// bin_count / sample_count / bin_area. - /// - /// - /// An alias for the density argument that behaves identically.

- /// To avoid - /// confusion with the broken normed argument to histogram, density - /// should be preferred. - /// - /// - /// An array of values w_i weighing each sample (x_i, y_i).

- /// - /// Weights are normalized to 1 if normed is True.

- /// If normed is - /// False, the values of the returned histogram are equal to the sum of - /// the weights belonging to the samples falling into each bin. - /// - /// - /// A tuple of: - /// H - /// The bi-dimensional histogram of samples x and y. Values in x - /// are histogrammed along the first dimension and values in y are - /// histogrammed along the second dimension. - /// xedges - /// The bin edges along the first dimension. - /// yedges - /// The bin edges along the second dimension. - /// - public (NDarray, NDarray, NDarray) histogram2d(NDarray y, NDarray bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - y, - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (density!=null) kwargs["density"]=ToPython(density); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogram2d", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1]), ToCsharp(py[2])); - } - - /// - /// Compute the bi-dimensional histogram of two data samples.

- /// - /// Notes - /// - /// When normed is True, then the returned histogram is the sample - /// density, defined such that the sum over bins of the product - /// bin_value * bin_area is 1.

- /// - /// Please note that the histogram does not follow the Cartesian convention - /// where x values are on the abscissa and y values on the ordinate - /// axis.

- /// Rather, x is histogrammed along the first dimension of the - /// array (vertical), and y along the second dimension of the array - /// (horizontal).

- /// This ensures compatibility with histogramdd. - /// - /// - /// An array containing the y coordinates of the points to be - /// histogrammed. - /// - /// - /// The bin specification: - /// - /// - /// The leftmost and rightmost edges of the bins along each dimension - /// (if not specified explicitly in the bins parameters): - /// [[xmin, xmax], [ymin, ymax]].

- /// All values outside of this range - /// will be considered outliers and not tallied in the histogram. - /// - /// - /// If False, the default, returns the number of samples in each bin.

- /// - /// If True, returns the probability density function at the bin, - /// bin_count / sample_count / bin_area. - /// - /// - /// An alias for the density argument that behaves identically.

- /// To avoid - /// confusion with the broken normed argument to histogram, density - /// should be preferred. - /// - /// - /// An array of values w_i weighing each sample (x_i, y_i).

- /// - /// Weights are normalized to 1 if normed is True.

- /// If normed is - /// False, the values of the returned histogram are equal to the sum of - /// the weights belonging to the samples falling into each bin. - /// - /// - /// A tuple of: - /// H - /// The bi-dimensional histogram of samples x and y. Values in x - /// are histogrammed along the first dimension and values in y are - /// histogrammed along the second dimension. - /// xedges - /// The bin edges along the first dimension. - /// yedges - /// The bin edges along the second dimension. - /// - public (NDarray, NDarray, NDarray) histogram2d(NDarray y, List bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - y, - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (density!=null) kwargs["density"]=ToPython(density); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogram2d", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1]), ToCsharp(py[2])); - } - - /// - /// Compute the multidimensional histogram of some data. - /// - /// - /// The bin specification: - /// - /// - /// A sequence of length D, each an optional (lower, upper) tuple giving - /// the outer bin edges to be used if the edges are not given explicitly in - /// bins.

- /// - /// An entry of None in the sequence results in the minimum and maximum - /// values being used for the corresponding dimension.

- /// - /// The default, None, is equivalent to passing a tuple of D None values. - /// - /// - /// If False, the default, returns the number of samples in each bin.

- /// - /// If True, returns the probability density function at the bin, - /// bin_count / sample_count / bin_volume. - /// - /// - /// An alias for the density argument that behaves identically.

- /// To avoid - /// confusion with the broken normed argument to histogram, density - /// should be preferred. - /// - /// - /// An array of values w_i weighing each sample (x_i, y_i, z_i, …).

- /// - /// Weights are normalized to 1 if normed is True.

- /// If normed is False, - /// the values of the returned histogram are equal to the sum of the - /// weights belonging to the samples falling into each bin. - /// - /// - /// A tuple of: - /// H - /// The multidimensional histogram of sample x. See normed and weights - /// for the different possible semantics. - /// edges - /// A list of D arrays describing the bin edges for each dimension. - /// - public (NDarray, NDarray) histogramdd(int? bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (density!=null) kwargs["density"]=ToPython(density); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogramdd", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Compute the multidimensional histogram of some data. - /// - /// - /// The bin specification: - /// - /// - /// A sequence of length D, each an optional (lower, upper) tuple giving - /// the outer bin edges to be used if the edges are not given explicitly in - /// bins.

- /// - /// An entry of None in the sequence results in the minimum and maximum - /// values being used for the corresponding dimension.

- /// - /// The default, None, is equivalent to passing a tuple of D None values. - /// - /// - /// If False, the default, returns the number of samples in each bin.

- /// - /// If True, returns the probability density function at the bin, - /// bin_count / sample_count / bin_volume. - /// - /// - /// An alias for the density argument that behaves identically.

- /// To avoid - /// confusion with the broken normed argument to histogram, density - /// should be preferred. - /// - /// - /// An array of values w_i weighing each sample (x_i, y_i, z_i, …).

- /// - /// Weights are normalized to 1 if normed is True.

- /// If normed is False, - /// the values of the returned histogram are equal to the sum of the - /// weights belonging to the samples falling into each bin. - /// - /// - /// A tuple of: - /// H - /// The multidimensional histogram of sample x. See normed and weights - /// for the different possible semantics. - /// edges - /// A list of D arrays describing the bin edges for each dimension. - /// - public (NDarray, NDarray) histogramdd(NDarray bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (density!=null) kwargs["density"]=ToPython(density); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogramdd", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Compute the multidimensional histogram of some data. - /// - /// - /// The bin specification: - /// - /// - /// A sequence of length D, each an optional (lower, upper) tuple giving - /// the outer bin edges to be used if the edges are not given explicitly in - /// bins.

- /// - /// An entry of None in the sequence results in the minimum and maximum - /// values being used for the corresponding dimension.

- /// - /// The default, None, is equivalent to passing a tuple of D None values. - /// - /// - /// If False, the default, returns the number of samples in each bin.

- /// - /// If True, returns the probability density function at the bin, - /// bin_count / sample_count / bin_volume. - /// - /// - /// An alias for the density argument that behaves identically.

- /// To avoid - /// confusion with the broken normed argument to histogram, density - /// should be preferred. - /// - /// - /// An array of values w_i weighing each sample (x_i, y_i, z_i, …).

- /// - /// Weights are normalized to 1 if normed is True.

- /// If normed is False, - /// the values of the returned histogram are equal to the sum of the - /// weights belonging to the samples falling into each bin. - /// - /// - /// A tuple of: - /// H - /// The multidimensional histogram of sample x. See normed and weights - /// for the different possible semantics. - /// edges - /// A list of D arrays describing the bin edges for each dimension. - /// - public (NDarray, NDarray) histogramdd(List bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (density!=null) kwargs["density"]=ToPython(density); - if (normed!=null) kwargs["normed"]=ToPython(normed); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogramdd", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1])); - } - - /// - /// Count number of occurrences of each value in array of non-negative ints.

- /// - /// The number of bins (of size 1) is one larger than the largest value in - /// x.

- /// If minlength is specified, there will be at least this number - /// of bins in the output array (though it will be longer if necessary, - /// depending on the contents of x).

- /// - /// Each bin gives the number of occurrences of its index value in x.

- /// - /// If weights is specified the input array is weighted by it, i.e.

- /// if a - /// value n is found at position i, out[n] += weight[i] instead - /// of out[n] += 1. - /// - /// - /// Weights, array of the same shape as x. - /// - /// - /// A minimum number of bins for the output array. - /// - /// - /// The result of binning the input array.

- /// - /// The length of out is equal to np.amax(x)+1. - /// - public NDarray bincount(NDarray weights = null, int? minlength = 0) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (weights!=null) kwargs["weights"]=ToPython(weights); - if (minlength!=0) kwargs["minlength"]=ToPython(minlength); - dynamic py = __self__.InvokeMethod("bincount", pyargs, kwargs); - return ToCsharp(py); - } - - /// - /// Function to calculate only the edges of the bins used by the histogram function.

- /// - /// Notes - /// - /// The methods to estimate the optimal number of bins are well founded - /// in literature, and are inspired by the choices R provides for - /// histogram visualisation.

- /// Note that having the number of bins - /// proportional to is asymptotically optimal, which is - /// why it appears in most estimators.

- /// These are simply plug-in methods - /// that give good starting points for number of bins.

- /// In the equations - /// below, is the binwidth and is the number of - /// bins.

- /// All estimators that compute bin counts are recast to bin width - /// using the ptp of the data.

- /// The final bin count is obtained from - /// np.round(np.ceil(range / h)). - /// - /// - /// If bins is an int, it defines the number of equal-width - /// bins in the given range (10, by default).

- /// If bins is a - /// sequence, it defines the bin edges, including the rightmost - /// edge, allowing for non-uniform bin widths.

- /// - /// If bins is a string from the list below, histogram_bin_edges will use - /// the method chosen to calculate the optimal bin width and - /// consequently the number of bins (see Notes for more detail on - /// the estimators) from the data that falls within the requested - /// range.

- /// While the bin width will be optimal for the actual data - /// in the range, the number of bins will be computed to fill the - /// entire range, including the empty portions.

- /// For visualisation, - /// using the ‘auto’ option is suggested.

- /// Weighted data is not - /// supported for automated bin size selection. - /// - /// - /// The lower and upper range of the bins.

- /// If not provided, range - /// is simply (a.min(), a.max()).

- /// Values outside the range are - /// ignored.

- /// The first element of the range must be less than or - /// equal to the second.

- /// range affects the automatic bin - /// computation as well.

- /// While bin width is computed to be optimal - /// based on the actual data within range, the bin count will fill - /// the entire range including portions containing no data. - /// - /// - /// An array of weights, of the same shape as a.

- /// Each value in - /// a only contributes its associated weight towards the bin count - /// (instead of 1).

- /// This is currently not used by any of the bin estimators, - /// but may be in the future. - /// - /// - /// The edges to pass into histogram - /// - public NDarray histogram_bin_edges(int? bins = null, (float, float)? range = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogram_bin_edges", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Function to calculate only the edges of the bins used by the histogram function.

- /// - /// Notes - /// - /// The methods to estimate the optimal number of bins are well founded - /// in literature, and are inspired by the choices R provides for - /// histogram visualisation.

- /// Note that having the number of bins - /// proportional to is asymptotically optimal, which is - /// why it appears in most estimators.

- /// These are simply plug-in methods - /// that give good starting points for number of bins.

- /// In the equations - /// below, is the binwidth and is the number of - /// bins.

- /// All estimators that compute bin counts are recast to bin width - /// using the ptp of the data.

- /// The final bin count is obtained from - /// np.round(np.ceil(range / h)). - /// - /// - /// If bins is an int, it defines the number of equal-width - /// bins in the given range (10, by default).

- /// If bins is a - /// sequence, it defines the bin edges, including the rightmost - /// edge, allowing for non-uniform bin widths.

- /// - /// If bins is a string from the list below, histogram_bin_edges will use - /// the method chosen to calculate the optimal bin width and - /// consequently the number of bins (see Notes for more detail on - /// the estimators) from the data that falls within the requested - /// range.

- /// While the bin width will be optimal for the actual data - /// in the range, the number of bins will be computed to fill the - /// entire range, including the empty portions.

- /// For visualisation, - /// using the ‘auto’ option is suggested.

- /// Weighted data is not - /// supported for automated bin size selection. - /// - /// - /// The lower and upper range of the bins.

- /// If not provided, range - /// is simply (a.min(), a.max()).

- /// Values outside the range are - /// ignored.

- /// The first element of the range must be less than or - /// equal to the second.

- /// range affects the automatic bin - /// computation as well.

- /// While bin width is computed to be optimal - /// based on the actual data within range, the bin count will fill - /// the entire range including portions containing no data. - /// - /// - /// An array of weights, of the same shape as a.

- /// Each value in - /// a only contributes its associated weight towards the bin count - /// (instead of 1).

- /// This is currently not used by any of the bin estimators, - /// but may be in the future. - /// - /// - /// The edges to pass into histogram - /// - public NDarray histogram_bin_edges(NDarray bins = null, (float, float)? range = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogram_bin_edges", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Function to calculate only the edges of the bins used by the histogram function.

- /// - /// Notes - /// - /// The methods to estimate the optimal number of bins are well founded - /// in literature, and are inspired by the choices R provides for - /// histogram visualisation.

- /// Note that having the number of bins - /// proportional to is asymptotically optimal, which is - /// why it appears in most estimators.

- /// These are simply plug-in methods - /// that give good starting points for number of bins.

- /// In the equations - /// below, is the binwidth and is the number of - /// bins.

- /// All estimators that compute bin counts are recast to bin width - /// using the ptp of the data.

- /// The final bin count is obtained from - /// np.round(np.ceil(range / h)). - /// - /// - /// If bins is an int, it defines the number of equal-width - /// bins in the given range (10, by default).

- /// If bins is a - /// sequence, it defines the bin edges, including the rightmost - /// edge, allowing for non-uniform bin widths.

- /// - /// If bins is a string from the list below, histogram_bin_edges will use - /// the method chosen to calculate the optimal bin width and - /// consequently the number of bins (see Notes for more detail on - /// the estimators) from the data that falls within the requested - /// range.

- /// While the bin width will be optimal for the actual data - /// in the range, the number of bins will be computed to fill the - /// entire range, including the empty portions.

- /// For visualisation, - /// using the ‘auto’ option is suggested.

- /// Weighted data is not - /// supported for automated bin size selection. - /// - /// - /// The lower and upper range of the bins.

- /// If not provided, range - /// is simply (a.min(), a.max()).

- /// Values outside the range are - /// ignored.

- /// The first element of the range must be less than or - /// equal to the second.

- /// range affects the automatic bin - /// computation as well.

- /// While bin width is computed to be optimal - /// based on the actual data within range, the bin count will fill - /// the entire range including portions containing no data. - /// - /// - /// An array of weights, of the same shape as a.

- /// Each value in - /// a only contributes its associated weight towards the bin count - /// (instead of 1).

- /// This is currently not used by any of the bin estimators, - /// but may be in the future. - /// - /// - /// The edges to pass into histogram - /// - public NDarray histogram_bin_edges(List bins = null, (float, float)? range = null, NDarray weights = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - }); - var kwargs=new PyDict(); - if (bins!=null) kwargs["bins"]=ToPython(bins); - if (range!=null) kwargs["range"]=ToPython(range); - if (weights!=null) kwargs["weights"]=ToPython(weights); - dynamic py = __self__.InvokeMethod("histogram_bin_edges", pyargs, kwargs); - return ToCsharp>(py); - } - - /// - /// Return the indices of the bins to which each value in input array belongs.

- /// - /// If values in x are beyond the bounds of bins, 0 or len(bins) is - /// returned as appropriate.

- /// - /// Notes - /// - /// If values in x are such that they fall outside the bin range, - /// attempting to index bins with the indices that digitize returns - /// will result in an IndexError.

- /// - /// np.digitize is implemented in terms of np.searchsorted.

- /// This means - /// that a binary search is used to bin the values, which scales much better - /// for larger number of bins than the previous linear search.

- /// It also removes - /// the requirement for the input array to be 1-dimensional.

- /// - /// For monotonically _increasing_ bins, the following are equivalent: - /// - /// Note that as the order of the arguments are reversed, the side must be too.

- /// - /// The searchsorted call is marginally faster, as it does not do any - /// monotonicity checks.

- /// Perhaps more importantly, it supports all dtypes. - /// - /// - /// Array of bins.

- /// It has to be 1-dimensional and monotonic. - /// - /// - /// Indicating whether the intervals include the right or the left bin - /// edge.

- /// Default behavior is (right==False) indicating that the interval - /// does not include the right edge.

- /// The left bin end is open in this - /// case, i.e., bins[i-1] <= x < bins[i] is the default behavior for - /// monotonically increasing bins. - /// - /// - /// Output array of indices, of same shape as x. - /// - public NDarray digitize(NDarray bins, bool? right = false) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - bins, - }); - var kwargs=new PyDict(); - if (right!=false) kwargs["right"]=ToPython(right); - dynamic py = __self__.InvokeMethod("digitize", pyargs, kwargs); - return ToCsharp(py); - } - } } diff --git a/src/Numpy/Models/PythonObject.cs b/src/Numpy/Models/PythonObject.cs index 5804762..220c165 100644 --- a/src/Numpy/Models/PythonObject.cs +++ b/src/Numpy/Models/PythonObject.cs @@ -57,5 +57,16 @@ public static PythonObject Create(string python_class) { throw new NotImplementedException(); } + + public static bool IsNDarray(dynamic py) + { + return np.ToCsharp(py.__class__.__name__) == "ndarray"; + } + + public static bool IsTuple(dynamic py) + { + return np.ToCsharp(py.__class__.__name__) == "tuple"; + } + } } diff --git a/src/Numpy/Models/PythonObject.gen.cs b/src/Numpy/Models/PythonObject.gen.cs index fca7ada..ffd56b3 100644 --- a/src/Numpy/Models/PythonObject.gen.cs +++ b/src/Numpy/Models/PythonObject.gen.cs @@ -39,7 +39,7 @@ public PyObject ToPython(object obj) { // basic types case int o: return new PyInt(o); - case long o: return new PyLong(o); + case long o: return new PyInt(o); case float o: return new PyFloat(o); case double o: return new PyFloat(o); case string o: return new PyString(o); @@ -87,13 +87,22 @@ public T ToCsharp(dynamic pyobj) return (T) (object) rv; case "Matrix": return (T)(object)new Matrix(pyobj); default: + var pyClass = $"{pyobj.__class__}"; + if (pyClass == "") + { + return (T)(object)pyobj.ToString(); + } + if (pyClass.StartsWith("(); + } try { return pyobj.As(); } catch (Exception e) { - throw new NotImplementedException($"conversion from {typeof(T).Name} to {pyobj.__class__} not implemented", e); + throw new NotImplementedException($"conversion from {pyobj.__class__} to {typeof(T).Name} not implemented", e); return default(T); } } diff --git a/src/Numpy/Numpy.csproj b/src/Numpy/Numpy.csproj index 074f489..fd803e2 100644 --- a/src/Numpy/Numpy.csproj +++ b/src/Numpy/Numpy.csproj @@ -14,8 +14,10 @@ https://github.com/SciSharp/Numpy.NET Data science, Machine Learning, ML, AI, Scientific Computing, NumPy, Linear Algebra, FFT, SVD, Matrix, Python https://github.com/SciSharp/Numpy.NET/blob/master/LICENSE - 3.7.1.25 + 3.11.1.35 https://github.com/SciSharp/Numpy.NET/blob/master/doc/img/numpy.net.icon128.png?raw=true + 3.10.0.0 + 3.10.0.0 @@ -27,16 +29,16 @@ - + - + - - + + diff --git a/src/Numpy/Resources/numpy-1.16.3-cp37-cp37m-win_amd64.whl b/src/Numpy/Resources/numpy-1.23.5-cp311-cp311-win_amd64.whl similarity index 54% rename from src/Numpy/Resources/numpy-1.16.3-cp37-cp37m-win_amd64.whl rename to src/Numpy/Resources/numpy-1.23.5-cp311-cp311-win_amd64.whl index 1edf2dd..b7c3051 100644 Binary files a/src/Numpy/Resources/numpy-1.16.3-cp37-cp37m-win_amd64.whl and b/src/Numpy/Resources/numpy-1.23.5-cp311-cp311-win_amd64.whl differ diff --git a/src/Numpy/np.array_manipulation.gen.cs b/src/Numpy/np.array_manipulation.gen.cs index c350b6a..d032a45 100644 --- a/src/Numpy/np.array_manipulation.gen.cs +++ b/src/Numpy/np.array_manipulation.gen.cs @@ -144,7 +144,7 @@ public static void copyto(NDarray dst, NDarray src, string casting = "same_kind" /// Note there is no guarantee of the memory layout (C- or /// Fortran- contiguous) of the returned array. /// - public static NDarray reshape(NDarray a, Shape newshape, string order = null) + public static NDarray reshape(this NDarray a, Shape newshape, string order = null) { //auto-generated code, do not change var __self__=self; @@ -218,7 +218,7 @@ public static NDarray reshape(NDarray a, Shape newshape, string order = null) /// Note that matrices are special cased for backward compatibility, if a /// is a matrix, then y is a 1-D ndarray. /// - public static NDarray ravel(NDarray a, string order = null) + public static NDarray ravel(this NDarray a, string order = null) { //auto-generated code, do not change var __self__=self; @@ -285,7 +285,7 @@ public static NDarray flatten(string order = null) /// Array with moved axes.

/// This array is a view of the input array. /// - public static NDarray moveaxis(NDarray a, int[] source, int[] destination) + public static NDarray moveaxis(this NDarray a, int[] source, int[] destination) { //auto-generated code, do not change var __self__=self; @@ -327,7 +327,7 @@ public static NDarray moveaxis(NDarray a, int[] source, int[] destination) /// NumPy versions a view of a is returned only if the order of the /// axes is changed, otherwise the input array is returned. /// - public static NDarray rollaxis(NDarray a, int axis, int? start = 0) + public static NDarray rollaxis(this NDarray a, int axis, int? start = 0) { //auto-generated code, do not change var __self__=self; @@ -361,7 +361,7 @@ public static NDarray rollaxis(NDarray a, int axis, int? start = 0) /// versions a view of a is returned only if the order of the /// axes is changed, otherwise the input array is returned. /// - public static NDarray swapaxes(NDarray a, int axis1, int axis2) + public static NDarray swapaxes(this NDarray a, int axis1, int axis2) { //auto-generated code, do not change var __self__=self; @@ -398,7 +398,7 @@ public static NDarray swapaxes(NDarray a, int axis1, int axis2) /// A view is returned whenever /// possible. /// - public static NDarray transpose(NDarray a, int[] axes = null) + public static NDarray transpose(this NDarray a, int[] axes = null) { //auto-generated code, do not change var __self__=self; @@ -434,7 +434,7 @@ public static NDarray transpose(NDarray a, int[] axes = null) /// A view is returned whenever /// possible. /// - public static NDarray transpose(NDarray[] a, int[] axes = null) + public static NDarray transpose(this NDarray[] a, int[] axes = null) { //auto-generated code, do not change var __self__=self; @@ -552,7 +552,7 @@ public static NDarray atleast_3d(params NDarray[] arys) /// Amongst others, it has shape and nd properties, and /// may be used as an iterator. /// - public static NDarray broadcast(NDarray in2, NDarray in1) + public static NDarray broadcast(this NDarray in2, NDarray in1) { //auto-generated code, do not change var __self__=self; @@ -588,7 +588,7 @@ public static NDarray broadcast(NDarray in2, NDarray in1) /// Furthermore, more than one element of a /// broadcasted array may refer to a single memory location. /// - public static NDarray broadcast_to(NDarray array, Shape shape, bool? subok = false) + public static NDarray broadcast_to(this NDarray array, Shape shape, bool? subok = false) { //auto-generated code, do not change var __self__=self; @@ -653,7 +653,7 @@ public static NDarray[] broadcast_arrays(NDarray[] args, bool? subok = null) /// The number of dimensions is one greater than that of /// the input array. /// - public static NDarray expand_dims(NDarray a, int axis) + public static NDarray expand_dims(this NDarray a, int axis) { //auto-generated code, do not change var __self__=self; @@ -685,7 +685,7 @@ public static NDarray expand_dims(NDarray a, int axis) /// This is always a itself /// or a view into a. /// - public static NDarray squeeze(NDarray a, Axis axis = null) + public static NDarray squeeze(this NDarray a, Axis axis = null) { //auto-generated code, do not change var __self__=self; @@ -713,7 +713,7 @@ public static NDarray squeeze(NDarray a, Axis axis = null) /// /// The input a as a float ndarray. /// - public static NDarray asfarray(NDarray a, Dtype dtype = null) + public static NDarray asfarray(this NDarray a, Dtype dtype = null) { //auto-generated code, do not change var __self__=self; @@ -739,7 +739,7 @@ public static NDarray asfarray(NDarray a, Dtype dtype = null) /// /// The input a in Fortran, or column-major, order. /// - public static NDarray asfortranarray(NDarray a, Dtype dtype = null) + public static NDarray asfortranarray(this NDarray a, Dtype dtype = null) { //auto-generated code, do not change var __self__=self; @@ -779,7 +779,7 @@ public static NDarray asfortranarray(NDarray a, Dtype dtype = null) /// If a is a subclass of ndarray, a base /// class ndarray is returned. /// - public static NDarray asarray_chkfinite(NDarray a, Dtype dtype = null, string order = null) + public static NDarray asarray_chkfinite(this NDarray a, Dtype dtype = null, string order = null) { //auto-generated code, do not change var __self__=self; @@ -818,7 +818,7 @@ public static NDarray asarray_chkfinite(NDarray a, Dtype dtype = null, string or /// /// The requirements list can be any of the following /// - public static NDarray require(NDarray a, Dtype dtype, string[] requirements = null) + public static NDarray require(this NDarray a, Dtype dtype, string[] requirements = null) { //auto-generated code, do not change var __self__=self; @@ -1118,7 +1118,48 @@ public static NDarray block(nested list of array_like or scalars (but not tuples /// /// A list of sub-arrays. /// - public static NDarray[] split(NDarray ary, int[] indices_or_sections, int? axis = 0) + public static NDarray[] split(this NDarray ary, int[] indices_or_sections, int? axis = 0) + { + //auto-generated code, do not change + var __self__=self; + var pyargs=ToTuple(new object[] + { + ary, + indices_or_sections, + }); + var kwargs=new PyDict(); + if (axis!=0) kwargs["axis"]=ToPython(axis); + dynamic py = __self__.InvokeMethod("split", pyargs, kwargs); + return ToCsharp(py); + } + + /// + /// Split an array into multiple sub-arrays. + /// + /// + /// Array to be divided into sub-arrays. + /// + /// + /// If indices_or_sections is an integer, N, the array will be divided + /// into N equal arrays along axis.

+ /// If such a split is not possible, + /// an error is raised.

+ /// + /// If indices_or_sections is a 1-D array of sorted integers, the entries + /// indicate where along axis the array is split.

+ /// For example, + /// [2, 3] would, for axis=0, result in + /// + /// If an index exceeds the dimension of the array along axis, + /// an empty sub-array is returned correspondingly. + /// + /// + /// The axis along which to split, default is 0. + /// + /// + /// A list of sub-arrays. + /// + public static NDarray[] split(this NDarray ary, int indices_or_sections, int? axis = 0) { //auto-generated code, do not change var __self__=self; @@ -1164,7 +1205,7 @@ public static NDarray[] split(NDarray ary, int[] indices_or_sections, int? axis /// /// The tiled output array. /// - public static NDarray tile(NDarray A, NDarray reps) + public static NDarray tile(this NDarray A, NDarray reps) { //auto-generated code, do not change var __self__=self; @@ -1198,7 +1239,7 @@ public static NDarray tile(NDarray A, NDarray reps) /// Output array which has the same shape as a, except along /// the given axis. /// - public static NDarray repeat(NDarray a, int[] repeats, int? axis = null) + public static NDarray repeat(this NDarray a, int[] repeats, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -1245,7 +1286,7 @@ public static NDarray repeat(NDarray a, int[] repeats, int? axis = null) /// If axis is None, out is /// a flattened array. /// - public static NDarray delete(NDarray arr, Slice obj, int? axis = null) + public static NDarray delete(this NDarray arr, Slice obj, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -1260,62 +1301,6 @@ public static NDarray delete(NDarray arr, Slice obj, int? axis = null) return ToCsharp(py); } - /// - /// Insert values along the given axis before the given indices.

- /// - /// Notes - /// - /// Note that for higher dimensional inserts obj=0 behaves very different - /// from obj=[0] just like arr[:,0,:] = values is different from - /// arr[:,[0],:] = values. - /// - /// - /// Input array. - /// - /// - /// Object that defines the index or indices before which values is - /// inserted.

- /// - /// Support for multiple insertions when obj is a single scalar or a - /// sequence with one element (similar to calling insert multiple - /// times). - /// - /// - /// Values to insert into arr.

- /// If the type of values is different - /// from that of arr, values is converted to the type of arr.

- /// - /// values should be shaped so that arr[...,obj,...] = values - /// is legal. - /// - /// - /// Axis along which to insert values.

- /// If axis is None then arr - /// is flattened first. - /// - /// - /// A copy of arr with values inserted.

- /// Note that insert - /// does not occur in-place: a new array is returned.

- /// If - /// axis is None, out is a flattened array. - /// - public static NDarray insert(NDarray arr, int obj = 0, NDarray values = null, int? axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - arr, - }); - var kwargs=new PyDict(); - if (obj!=0) kwargs["obj"]=ToPython(obj); - if (values!=null) kwargs["values"]=ToPython(values); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("insert", pyargs, kwargs); - return ToCsharp(py); - } - /// /// Append values to the end of an array. /// @@ -1342,7 +1327,7 @@ public static NDarray insert(NDarray arr, int obj = 0, NDarray values = null, in /// filled.

/// If axis is None, out is a flattened array. /// - public static NDarray append(NDarray arr, NDarray values, int? axis = null) + public static NDarray append(this NDarray arr, NDarray values, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -1373,7 +1358,7 @@ public static NDarray append(NDarray arr, NDarray values, int? axis = null) /// The result of trimming the input.

/// The input data type is preserved. /// - public static NDarray trim_zeros(NDarray filt, string trim = "fb") + public static NDarray trim_zeros(this NDarray filt, string trim = "fb") { //auto-generated code, do not change var __self__=self; @@ -1495,7 +1480,7 @@ public static NDarray unique(NDarray ar, int? axis = null) /// /// The sorted unique values. /// - public static NDarray[] unique(NDarray ar, bool return_index, bool return_inverse, bool return_counts, int? axis = null) + public static NDarray[] unique(this NDarray ar, bool return_index, bool return_inverse, bool return_counts, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -1549,7 +1534,7 @@ public static NDarray[] unique(NDarray ar, bool return_index, bool return_invers /// Since a view is /// returned, this operation is done in constant time. /// - public static NDarray flip(NDarray m, Axis axis = null) + public static NDarray flip(this NDarray m, Axis axis = null) { //auto-generated code, do not change var __self__=self; @@ -1583,7 +1568,7 @@ public static NDarray flip(NDarray m, Axis axis = null) /// Since a view /// is returned, this operation is . /// - public static NDarray fliplr(NDarray m) + public static NDarray fliplr(this NDarray m) { //auto-generated code, do not change var __self__=self; @@ -1617,7 +1602,7 @@ public static NDarray fliplr(NDarray m) /// Since a view is /// returned, this operation is . /// - public static NDarray flipud(NDarray m) + public static NDarray flipud(this NDarray m) { //auto-generated code, do not change var __self__=self; @@ -1661,7 +1646,7 @@ public static NDarray flipud(NDarray m) /// /// Output array, with the same shape as a. /// - public static NDarray roll(NDarray a, int[] shift, Axis axis = null) + public static NDarray roll(this NDarray a, int[] shift, Axis axis = null) { //auto-generated code, do not change var __self__=self; @@ -1700,7 +1685,7 @@ public static NDarray roll(NDarray a, int[] shift, Axis axis = null) /// /// A rotated view of m. /// - public static NDarray rot90(NDarray m, int k = 1, int[] axes = null) + public static NDarray rot90(this NDarray m, int k = 1, int[] axes = null) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.bitwise.gen.cs b/src/Numpy/np.bitwise.gen.cs index 77857e7..6e0ffbb 100644 --- a/src/Numpy/np.bitwise.gen.cs +++ b/src/Numpy/np.bitwise.gen.cs @@ -51,7 +51,7 @@ public static partial class np /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray bitwise_and(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray bitwise_and(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -99,7 +99,7 @@ public static NDarray bitwise_and(NDarray x2, NDarray x1, NDarray @out = null, N /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray bitwise_or(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray bitwise_or(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -147,7 +147,7 @@ public static NDarray bitwise_or(NDarray x2, NDarray x1, NDarray @out = null, ND /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray bitwise_xor(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray bitwise_xor(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -208,7 +208,7 @@ public static NDarray bitwise_xor(NDarray x2, NDarray x1, NDarray @out = null, N /// /// This is a scalar if x is a scalar. /// - public static NDarray invert(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray invert(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -301,7 +301,7 @@ public static NDarray left_shift(NDarray x1, NDarray x2, NDarray /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray right_shift(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray right_shift(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -338,7 +338,7 @@ public static NDarray right_shift(NDarray x1, NDarray x2, NDarray @out = null, N /// packed has the same number of dimensions as the input (unless axis /// is None, in which case the output is 1-D). /// - public static NDarray packbits(NDarray myarray, int? axis = null) + public static NDarray packbits(this NDarray myarray, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -372,7 +372,7 @@ public static NDarray packbits(NDarray myarray, int? axis = null) /// /// The elements are binary-valued (0 or 1). /// - public static NDarray unpackbits(NDarray myarray, int? axis = null) + public static NDarray unpackbits(this NDarray myarray, int? axis = null) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.dtype.routines.gen.cs b/src/Numpy/np.dtype.routines.gen.cs index 92ba698..b02cba6 100644 --- a/src/Numpy/np.dtype.routines.gen.cs +++ b/src/Numpy/np.dtype.routines.gen.cs @@ -119,7 +119,7 @@ public static Dtype promote_types(Dtype type1, Dtype type2) /// /// The minimal data type. /// - public static Dtype min_scalar_type(NDarray a) + public static Dtype min_scalar_type(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -215,7 +215,7 @@ public static Dtype result_type(list of arrays and dtypes arrays_and_dtypes) /// /// Data type code. /// - public static Dtype common_type(NDarray array2, NDarray array1) + public static Dtype common_type(this NDarray array2, NDarray array1) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.financial.gen.cs b/src/Numpy/np.financial.gen.cs index 0ea9927..9210c0b 100644 --- a/src/Numpy/np.financial.gen.cs +++ b/src/Numpy/np.financial.gen.cs @@ -55,7 +55,7 @@ public static partial class np /// /// If multiple inputs are array_like, they all must have the same shape. /// - public static NDarray fv(NDarray rate, NDarray nper, NDarray pmt, NDarray pv, string @when = "end") + public static NDarray fv(this NDarray rate, NDarray nper, NDarray pmt, NDarray pv, string @when = "end") { //auto-generated code, do not change var __self__=self; @@ -103,7 +103,7 @@ public static NDarray fv(NDarray rate, NDarray nper, NDarray pmt, NDarray pv, st /// /// Present value of a series of payments or investments. /// - public static NDarray pv(NDarray rate, NDarray nper, NDarray pmt, NDarray fv = null, string @when = "end") + public static NDarray pv(this NDarray rate, NDarray nper, NDarray pmt, NDarray fv = null, string @when = "end") { //auto-generated code, do not change var __self__=self; @@ -206,7 +206,7 @@ public static float npv(ValueType rate, NDarray values) /// If multiple inputs are array_like, they all must have /// the same shape. /// - public static NDarray pmt(NDarray rate, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") + public static NDarray pmt(this NDarray rate, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") { //auto-generated code, do not change var __self__=self; @@ -246,7 +246,7 @@ public static NDarray pmt(NDarray rate, NDarray nper, NDarray pv, NDarray fv = n /// /// When payments are due (‘begin’ (1) or ‘end’ (0)) /// - public static void ppmt(NDarray rate, NDarray per, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") + public static void ppmt(this NDarray rate, NDarray per, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") { //auto-generated code, do not change var __self__=self; @@ -303,7 +303,7 @@ public static void ppmt(NDarray rate, NDarray per, NDarray nper, NDarray pv, NDa /// If multiple inputs are array_like, they all must have /// the same shape. /// - public static NDarray ipmt(NDarray rate, NDarray per, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") + public static NDarray ipmt(this NDarray rate, NDarray per, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end") { //auto-generated code, do not change var __self__=self; @@ -358,7 +358,7 @@ public static NDarray ipmt(NDarray rate, NDarray per, NDarray nper, NDarray pv, /// /// Internal Rate of Return for periodic input values. /// - public static float irr(NDarray values) + public static float irr(this NDarray values) { //auto-generated code, do not change var __self__=self; @@ -389,7 +389,7 @@ public static float irr(NDarray values) /// /// Modified internal rate of return /// - public static float mirr(NDarray values, ValueType finance_rate, ValueType reinvest_rate) + public static float mirr(this NDarray values, ValueType finance_rate, ValueType reinvest_rate) { //auto-generated code, do not change var __self__=self; @@ -430,7 +430,7 @@ public static float mirr(NDarray values, ValueType finance_rate, ValueType reinv /// /// When payments are due (‘begin’ (1) or ‘end’ (0)) /// - public static void nper(NDarray rate, NDarray pmt, NDarray pv, NDarray fv = null, string @when = "end") + public static void nper(this NDarray rate, NDarray pmt, NDarray pv, NDarray fv = null, string @when = "end") { //auto-generated code, do not change var __self__=self; @@ -497,7 +497,7 @@ public static void nper(NDarray rate, NDarray pmt, NDarray pv, NDarray fv = null /// /// Maximum iterations in finding the solution /// - public static void rate(NDarray nper, NDarray pmt, NDarray pv, NDarray fv, string @when = "end", double? guess = null, double? tol = null, int? maxiter = 100) + public static void rate(this NDarray nper, NDarray pmt, NDarray pv, NDarray fv, string @when = "end", double? guess = null, double? tol = null, int? maxiter = 100) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.indexing.gen.cs b/src/Numpy/np.indexing.gen.cs index ca8d8fb..1d2d8b5 100644 --- a/src/Numpy/np.indexing.gen.cs +++ b/src/Numpy/np.indexing.gen.cs @@ -132,7 +132,7 @@ public static void s_(bool maketuple) /// /// Indices of elements that are non-zero. /// - public static NDarray[] nonzero(NDarray a) + public static NDarray[] nonzero(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -169,7 +169,7 @@ public static NDarray[] nonzero(NDarray a) /// An array with elements from x where condition is True, and elements /// from y elsewhere. /// - public static NDarray @where(NDarray condition, NDarray y, NDarray x) + public static NDarray @where(this NDarray condition, NDarray y, NDarray x) { //auto-generated code, do not change var __self__=self; @@ -198,7 +198,7 @@ public static NDarray @where(NDarray condition, NDarray y, NDarray x) /// An array with elements from x where condition is True, and elements /// from y elsewhere. /// - public static NDarray[] @where(NDarray condition) + public static NDarray[] @where(this NDarray condition) { //auto-generated code, do not change var __self__=self; @@ -359,7 +359,7 @@ public static NDarray ravel_multi_index(tuple of array_like multi_index, tuple o /// Each array in the tuple has the same shape as the indices /// array. /// - public static NDarray[] unravel_index(NDarray indices, Shape shape, string order = null) + public static NDarray[] unravel_index(this NDarray indices, Shape shape, string order = null) { //auto-generated code, do not change var __self__=self; @@ -413,7 +413,7 @@ public static void diag_indices(int n, int? ndim = 2) /// /// Notes /// - public static void diag_indices_from(NDarray arr) + public static void diag_indices_from(this NDarray arr) { //auto-generated code, do not change var __self__=self; @@ -524,7 +524,7 @@ public static NDarray[] tril_indices(int n, int? k = 0, int? m = null) /// /// Diagonal offset (see tril for details). /// - public static void tril_indices_from(NDarray arr, int? k = 0) + public static void tril_indices_from(this NDarray arr, int? k = 0) { //auto-generated code, do not change var __self__=self; @@ -593,7 +593,7 @@ public static NDarray[] triu_indices(int n, int? k = 0, int? m = null) /// /// Indices for the upper-triangle of arr. /// - public static NDarray[] triu_indices_from(NDarray arr, int? k = 0) + public static NDarray[] triu_indices_from(this NDarray arr, int? k = 0) { //auto-generated code, do not change var __self__=self; @@ -709,7 +709,7 @@ public static NDarray take(NDarray[] a, NDarray[] indices, int? axis = null, NDa /// treated as if it had first been flattened to 1d, for consistency with /// sort and argsort. /// - public static NDarray take_along_axis(NDarray arr, NDarray indices, int? axis = null) + public static NDarray take_along_axis(this NDarray arr, NDarray indices, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -907,7 +907,7 @@ public static NDarray compress(NDarray condition, NDarray a, int? axis = n /// are removed, and a new axis inserted at the end corresponding to the /// diagonal. /// - public static NDarray diagonal(NDarray a, int? offset = 0, int? axis1 = 0, int? axis2 = 1) + public static NDarray diagonal(this NDarray a, int? offset = 0, int? axis1 = 0, int? axis2 = 1) { //auto-generated code, do not change var __self__=self; @@ -1059,7 +1059,7 @@ public static NDarray as_strided(NDarray x, Shape shape = null, int[] strides = /// than N, it will be repeated, and if elements of a are to be masked, /// this sequence must be non-empty. /// - public static void place(NDarray arr, NDarray mask, NDarray vals) + public static void place(this NDarray arr, NDarray mask, NDarray vals) { //auto-generated code, do not change var __self__=self; @@ -1099,7 +1099,7 @@ public static void place(NDarray arr, NDarray mask, NDarray vals) /// Note /// that this disables indexing with negative numbers. /// - public static void put(NDarray a, NDarray ind, NDarray v, string mode = "raise") + public static void put(this NDarray a, NDarray ind, NDarray v, string mode = "raise") { //auto-generated code, do not change var __self__=self; @@ -1151,7 +1151,7 @@ public static void put(NDarray a, NDarray ind, NDarray v, string mode = "raise") /// If axis is None, the destination /// array is treated as if a flattened 1d view had been created of it. /// - public static void put_along_axis(NDarray arr, NDarray indices, NDarray[] values, int axis) + public static void put_along_axis(this NDarray arr, NDarray indices, NDarray[] values, int axis) { //auto-generated code, do not change var __self__=self; @@ -1187,7 +1187,7 @@ public static void put_along_axis(NDarray arr, NDarray indices, NDarray[] values /// If values is smaller /// than a it will be repeated. /// - public static void putmask(NDarray a, NDarray mask, NDarray values) + public static void putmask(this NDarray a, NDarray mask, NDarray values) { //auto-generated code, do not change var __self__=self; @@ -1229,7 +1229,7 @@ public static void putmask(NDarray a, NDarray mask, NDarray values) /// with this option.

/// This affects only tall matrices. /// - public static void fill_diagonal(NDarray a, ValueType val, bool wrap = false) + public static void fill_diagonal(this NDarray a, ValueType val, bool wrap = false) { //auto-generated code, do not change var __self__=self; @@ -1317,7 +1317,7 @@ public static void fill_diagonal(NDarray a, ValueType val, bool wrap = false) /// buffers.

/// Set to 0 for the default value. /// - public static void nditer(NDarray op, string[] flags = null, list of list of str op_flags = null, dtype or tuple of dtype(s) op_dtypes = null, string order = null, string casting = null, list of list of ints op_axes = null, tuple of ints itershape = null, int? buffersize = null) + public static void nditer(this NDarray op, string[] flags = null, list of list of str op_flags = null, dtype or tuple of dtype(s) op_dtypes = null, string order = null, string casting = null, list of list of ints op_axes = null, tuple of ints itershape = null, int? buffersize = null) { //auto-generated code, do not change var __self__=self; @@ -1346,7 +1346,7 @@ public static void nditer(NDarray op, string[] flags = null, list of list of str /// /// Input array. /// - public static void ndenumerate(NDarray arr) + public static void ndenumerate(this NDarray arr) { //auto-generated code, do not change var __self__=self; @@ -1401,7 +1401,7 @@ public static void ndindex(params int[] args) /// /// An nditer for each item in axes, outermost first /// - public static tuple of nditer nested_iters(NDarray op, int[] axes = null) + public static tuple of nditer nested_iters(this NDarray op, int[] axes = null) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.io.gen.cs b/src/Numpy/np.io.gen.cs index 25fbf28..8e09d8f 100644 --- a/src/Numpy/np.io.gen.cs +++ b/src/Numpy/np.io.gen.cs @@ -579,7 +579,7 @@ public static List tolist() /// /// String representation of the array. /// - public static string array2string(NDarray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null, string separator = " ", string prefix = "", string suffix = "", dict of callables formatter = null, int? threshold = null, int? edgeitems = null, string sign = null, string floatmode = null, string or False legacy = null) + public static string array2string(this NDarray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null, string separator = " ", string prefix = "", string suffix = "", dict of callables formatter = null, int? threshold = null, int? edgeitems = null, string sign = null, string floatmode = null, string or False legacy = null) { //auto-generated code, do not change var __self__=self; @@ -630,7 +630,7 @@ public static string array2string(NDarray a, int? max_line_width = null, int? pr /// /// The string representation of an array. /// - public static string array_repr(NDarray arr, int? max_line_width = null, int? precision = null, bool? suppress_small = null) + public static string array_repr(this NDarray arr, int? max_line_width = null, int? precision = null, bool? suppress_small = null) { //auto-generated code, do not change var __self__=self; @@ -674,7 +674,7 @@ public static string array_repr(NDarray arr, int? max_line_width = null, int? pr /// numbers smaller (in absolute value) than 5e-9 are represented as /// zero. /// - public static void array_str(NDarray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null) + public static void array_str(this NDarray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.linalg.gen.cs b/src/Numpy/np.linalg.gen.cs index 3a47f9d..61256b6 100644 --- a/src/Numpy/np.linalg.gen.cs +++ b/src/Numpy/np.linalg.gen.cs @@ -49,7 +49,7 @@ public static partial class np /// /// If out is given, then it is returned. /// - public static NDarray dot(NDarray a, NDarray b, NDarray @out = null) + public static NDarray dot(this NDarray a, NDarray b, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -144,7 +144,7 @@ public static NDarray multi_dot(params NDarray[] arrays) /// Can be an int, float, or /// complex depending on the types of a and b. /// - public static NDarray vdot(NDarray a, NDarray b) + public static NDarray vdot(this NDarray a, NDarray b) { //auto-generated code, do not change var __self__=self; @@ -183,7 +183,7 @@ public static NDarray vdot(NDarray a, NDarray b) /// /// out.shape = a.shape[:-1] + b.shape[:-1] /// - public static NDarray inner(NDarray b, NDarray a) + public static NDarray inner(this NDarray b, NDarray a) { //auto-generated code, do not change var __self__=self; @@ -222,7 +222,7 @@ public static NDarray inner(NDarray b, NDarray a) /// /// out[i, j] = a[i] * b[j] /// - public static NDarray outer(NDarray a, NDarray b, NDarray @out = null) + public static NDarray outer(this NDarray a, NDarray b, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -267,7 +267,7 @@ public static NDarray outer(NDarray a, NDarray b, NDarray @out = null) /// /// This is a scalar only when both x1, x2 are 1-d vectors. /// - public static NDarray matmul(NDarray x2, NDarray x1, NDarray @out = null) + public static NDarray matmul(this NDarray x2, NDarray x1, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -312,7 +312,7 @@ public static NDarray matmul(NDarray x2, NDarray x1, NDarray @out = null) /// /// Tensors to “dot”. /// - public static NDarray tensordot(NDarray b, NDarray a, int[] axes = null) + public static NDarray tensordot(this NDarray b, NDarray a, int[] axes = null) { //auto-generated code, do not change var __self__=self; @@ -327,195 +327,6 @@ public static NDarray tensordot(NDarray b, NDarray a, int[] axes = null) return ToCsharp(py); } - /// - /// Evaluates the Einstein summation convention on the operands.

- /// - /// Using the Einstein summation convention, many common multi-dimensional, - /// linear algebraic array operations can be represented in a simple fashion.

- /// - /// In implicit mode einsum computes these values.

- /// - /// In explicit mode, einsum provides further flexibility to compute - /// other array operations that might not be considered classical Einstein - /// summation operations, by disabling, or forcing summation over specified - /// subscript labels.

- /// - /// See the notes and examples for clarification.

- /// - /// Notes - /// - /// The Einstein summation convention can be used to compute - /// many multi-dimensional, linear algebraic array operations.

- /// einsum - /// provides a succinct way of representing these.

- /// - /// A non-exhaustive list of these operations, - /// which can be computed by einsum, is shown below along with examples: - /// - /// The subscripts string is a comma-separated list of subscript labels, - /// where each label refers to a dimension of the corresponding operand.

- /// - /// Whenever a label is repeated it is summed, so np.einsum('i,i', a, b) - /// is equivalent to np.inner(a,b).

- /// If a label - /// appears only once, it is not summed, so np.einsum('i', a) produces a - /// view of a with no changes.

- /// A further example np.einsum('ij,jk', a, b) - /// describes traditional matrix multiplication and is equivalent to - /// np.matmul(a,b).

- /// Repeated subscript labels in one - /// operand take the diagonal.

- /// For example, np.einsum('ii', a) is equivalent - /// to np.trace(a).

- /// - /// In implicit mode, the chosen subscripts are important - /// since the axes of the output are reordered alphabetically.

- /// This - /// means that np.einsum('ij', a) doesn’t affect a 2D array, while - /// np.einsum('ji', a) takes its transpose.

- /// Additionally, - /// np.einsum('ij,jk', a, b) returns a matrix multiplication, while, - /// np.einsum('ij,jh', a, b) returns the transpose of the - /// multiplication since subscript ‘h’ precedes subscript ‘i’. - /// - /// In explicit mode the output can be directly controlled by - /// specifying output subscript labels.

- /// This requires the - /// identifier ‘->’ as well as the list of output subscript labels.

- /// - /// This feature increases the flexibility of the function since - /// summing can be disabled or forced when required.

- /// The call - /// np.einsum('i->', a) is like np.sum(a, axis=-1), - /// and np.einsum('ii->i', a) is like np.diag(a).

- /// - /// The difference is that einsum does not allow broadcasting by default.

- /// - /// Additionally np.einsum('ij,jh->ih', a, b) directly specifies the - /// order of the output subscript labels and therefore returns matrix - /// multiplication, unlike the example above in implicit mode.

- /// - /// To enable and control broadcasting, use an ellipsis.

- /// Default - /// NumPy-style broadcasting is done by adding an ellipsis - /// to the left of each term, like np.einsum('...ii->...i', a).

- /// - /// To take the trace along the first and last axes, - /// you can do np.einsum('i...i', a), or to do a matrix-matrix - /// product with the left-most indices instead of rightmost, one can do - /// np.einsum('ij...,jk...->ik...', a, b).

- /// - /// When there is only one operand, no axes are summed, and no output - /// parameter is provided, a view into the operand is returned instead - /// of a new array.

- /// Thus, taking the diagonal as np.einsum('ii->i', a) - /// produces a view (changed in version 1.10.0).

- /// - /// einsum also provides an alternative way to provide the subscripts - /// and operands as einsum(op0, sublist0, op1, sublist1, ..., [sublistout]).

- /// - /// If the output shape is not provided in this format einsum will be - /// calculated in implicit mode, otherwise it will be performed explicitly.

- /// - /// The examples below have corresponding einsum calls with the two - /// parameter methods.

- /// - /// Views returned from einsum are now writeable whenever the input array - /// is writeable.

- /// For example, np.einsum('ijk...->kji...', a) will now - /// have the same effect as np.swapaxes(a, 0, 2) - /// and np.einsum('ii->i', a) will return a writeable view of the diagonal - /// of a 2D array.

- /// - /// Added the optimize argument which will optimize the contraction order - /// of an einsum expression.

- /// For a contraction with three or more operands this - /// can greatly increase the computational efficiency at the cost of a larger - /// memory footprint during computation.

- /// - /// Typically a ‘greedy’ algorithm is applied which empirical tests have shown - /// returns the optimal path in the majority of cases.

- /// In some cases ‘optimal’ - /// will return the superlative path through a more expensive, exhaustive search.

- /// - /// For iterative calculations it may be advisable to calculate the optimal path - /// once and reuse that path by supplying it as an argument.

- /// An example is given - /// below.

- /// - /// See numpy.einsum_path for more details. - /// - /// - /// Specifies the subscripts for summation as comma separated list of - /// subscript labels.

- /// An implicit (classical Einstein summation) - /// calculation is performed unless the explicit indicator ‘->’ is - /// included as well as subscript labels of the precise output form. - /// - /// - /// These are the arrays for the operation. - /// - /// - /// If provided, the calculation is done into this array. - /// - /// - /// If provided, forces the calculation to use the data type specified.

- /// - /// Note that you may have to also give a more liberal casting - /// parameter to allow the conversions.

- /// Default is None. - /// - /// - /// Controls the memory layout of the output.

- /// ‘C’ means it should - /// be C contiguous.

- /// ‘F’ means it should be Fortran contiguous, - /// ‘A’ means it should be ‘F’ if the inputs are all ‘F’, ‘C’ otherwise.

- /// - /// ‘K’ means it should be as close to the layout as the inputs as - /// is possible, including arbitrarily permuted axes.

- /// - /// Default is ‘K’. - /// - /// - /// Controls what kind of data casting may occur.

- /// Setting this to - /// ‘unsafe’ is not recommended, as it can adversely affect accumulations.

- /// - /// Default is ‘safe’. - /// - /// - /// Controls if intermediate optimization should occur.

- /// No optimization - /// will occur if False and True will default to the ‘greedy’ algorithm.

- /// - /// Also accepts an explicit contraction list from the np.einsum_path - /// function.

- /// See np.einsum_path for more details.

- /// Defaults to False. - /// - /// - /// The calculation based on the Einstein summation convention. - /// - public static NDarray einsum(string subscripts, NDarray[] operands, NDarray @out = null, Dtype dtype = null, string order = null, string casting = "safe", object optimize = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - subscripts, - operands, - }); - var kwargs=new PyDict(); - if (@out!=null) kwargs["out"]=ToPython(@out); - if (dtype!=null) kwargs["dtype"]=ToPython(dtype); - if (order!=null) kwargs["order"]=ToPython(order); - if (casting!="safe") kwargs["casting"]=ToPython(casting); - if (optimize!=null) kwargs["optimize"]=ToPython(optimize); - dynamic py = __self__.InvokeMethod("einsum", pyargs, kwargs); - return ToCsharp(py); - } - /* /// /// Evaluates the lowest cost contraction order for an einsum expression by @@ -630,7 +441,7 @@ public static NDarray matrix_power(NDarray a, int n) /// /// In the common 2-D case (N=1), the block structure can be visualized: /// - public static NDarray kron(NDarray b, NDarray a) + public static NDarray kron(this NDarray b, NDarray a) { //auto-generated code, do not change var __self__=self; @@ -644,92 +455,6 @@ public static NDarray kron(NDarray b, NDarray a) return ToCsharp(py); } - public static partial class linalg { - /// - /// Compute the qr factorization of a matrix.

- /// - /// Factor the matrix a as qr, where q is orthonormal and r is - /// upper-triangular.

- /// - /// Notes - /// - /// This is an interface to the LAPACK routines dgeqrf, zgeqrf, - /// dorgqr, and zungqr.

- /// - /// For more information on the qr factorization, see for example: - /// https://en.wikipedia.org/wiki/QR_factorization - /// - /// Subclasses of ndarray are preserved except for the ‘raw’ mode.

- /// So if - /// a is of type matrix, all the return values will be matrices too.

- /// - /// New ‘reduced’, ‘complete’, and ‘raw’ options for mode were added in - /// NumPy 1.8.0 and the old option ‘full’ was made an alias of ‘reduced’. In - /// addition the options ‘full’ and ‘economic’ were deprecated.

- /// Because - /// ‘full’ was the previous default and ‘reduced’ is the new default, - /// backward compatibility can be maintained by letting mode default.

- /// - /// The ‘raw’ option was added so that LAPACK routines that can multiply - /// arrays by q using the Householder reflectors can be used.

- /// Note that in - /// this case the returned arrays are of type np.double or np.cdouble and - /// the h array is transposed to be FORTRAN compatible.

- /// No routines using - /// the ‘raw’ return are currently exposed by numpy, but some are available - /// in lapack_lite and just await the necessary work. - /// - /// - /// Matrix to be factored. - /// - /// - /// If K = min(M, N), then - /// - /// The options ‘reduced’, ‘complete, and ‘raw’ are new in numpy 1.8, - /// see the notes for more information.

- /// The default is ‘reduced’, and to - /// maintain backward compatibility with earlier versions of numpy both - /// it and the old default ‘full’ can be omitted.

- /// Note that array h - /// returned in ‘raw’ mode is transposed for calling Fortran.

- /// The - /// ‘economic’ mode is deprecated.

- /// The modes ‘full’ and ‘economic’ may - /// be passed using only the first letter for backwards compatibility, - /// but all others must be spelled out.

- /// See the Notes for more - /// explanation. - /// - /// - /// A tuple of: - /// q - /// A matrix with orthonormal columns. When mode = ‘complete’ the - /// result is an orthogonal/unitary matrix depending on whether or not - /// a is real/complex. The determinant may be either +/- 1 in that - /// case. - /// r - /// The upper-triangular matrix. - /// (h, tau) - /// The array h contains the Householder reflectors that generate q - /// along with r. The tau array contains scaling factors for the - /// reflectors. In the deprecated ‘economic’ mode only h is returned. - /// - public static (NDarray, NDarray, NDarray) qr(NDarray a, string mode = "reduced") - { - //auto-generated code, do not change - var linalg = self.GetAttr("linalg"); - var __self__=linalg; - var pyargs=ToTuple(new object[] - { - a, - }); - var kwargs=new PyDict(); - if (mode!="reduced") kwargs["mode"]=ToPython(mode); - dynamic py = __self__.InvokeMethod("qr", pyargs, kwargs); - return (ToCsharp(py[0]), ToCsharp(py[1]), ToCsharp(py[2])); - } - } - /* public static partial class linalg { /// @@ -969,7 +694,7 @@ public static (NDarray, NDarray) slogdet(NDarray a) /// If a has /// larger dimensions, then an array of sums along diagonals is returned. /// - public static NDarray trace(NDarray a, int? offset = 0, int? axis2 = null, int? axis1 = null, Dtype dtype = null, NDarray @out = null) + public static NDarray trace(this NDarray a, int? offset = 0, int? axis2 = null, int? axis1 = null, Dtype dtype = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.linalg_fft.gen.cs b/src/Numpy/np.linalg_fft.gen.cs index 512458d..d4d0676 100644 --- a/src/Numpy/np.linalg_fft.gen.cs +++ b/src/Numpy/np.linalg_fft.gen.cs @@ -1095,7 +1095,7 @@ public static NDarray ifftn(NDarray a, int[] s = null, int[] axes = null, string /// /// The modified Bessel function evaluated at each of the elements of x. /// - public static NDarray i0(NDarray x) + public static NDarray i0(this NDarray x) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.logic.gen.cs b/src/Numpy/np.logic.gen.cs index 9f07c3a..14e190f 100644 --- a/src/Numpy/np.logic.gen.cs +++ b/src/Numpy/np.logic.gen.cs @@ -67,7 +67,7 @@ public static partial class np /// A new boolean or array is returned unless out is specified, /// in which case a reference to out is returned. /// - public static NDarray all(NDarray a, Axis axis, NDarray @out = null, bool? keepdims = null) + public static NDarray all(this NDarray a, Axis axis, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -98,7 +98,7 @@ public static NDarray all(NDarray a, Axis axis, NDarray @out = null, bool? /// A new boolean or array is returned unless out is specified, /// in which case a reference to out is returned. /// - public static bool all(NDarray a) + public static bool all(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -161,7 +161,7 @@ public static bool all(NDarray a) /// A new boolean or ndarray is returned unless out is specified, /// in which case a reference to out is returned. /// - public static NDarray any(NDarray a, Axis axis, NDarray @out = null, bool? keepdims = null) + public static NDarray any(this NDarray a, Axis axis, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -194,7 +194,7 @@ public static NDarray any(NDarray a, Axis axis, NDarray @out = null, bool? /// A new boolean or ndarray is returned unless out is specified, /// in which case a reference to out is returned. /// - public static bool any(NDarray a) + public static bool any(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -250,7 +250,7 @@ public static bool any(NDarray a) /// /// This is a scalar if x is a scalar. /// - public static NDarray isfinite(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray isfinite(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -301,7 +301,7 @@ public static NDarray isfinite(NDarray x, NDarray @out = null, NDarray @where = /// /// This is a scalar if x is a scalar. /// - public static NDarray isinf(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray isinf(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -346,7 +346,7 @@ public static NDarray isinf(NDarray x, NDarray @out = null, NDarray @where /// /// This is a scalar if x is a scalar. /// - public static NDarray isnan(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray isnan(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -385,7 +385,7 @@ public static NDarray isnan(NDarray x, NDarray @out = null, NDarray @where = nul /// /// This is a scalar if x is a scalar. /// - public static NDarray isnat(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray isnat(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -434,7 +434,7 @@ public static NDarray isnat(NDarray x, NDarray @out = null, NDarray @where = nul /// The /// return value out is then a reference to that array. /// - public static NDarray isneginf(NDarray x, NDarray @out = null) + public static NDarray isneginf(this NDarray x, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -481,7 +481,7 @@ public static NDarray isneginf(NDarray x, NDarray @out = null) /// /// The return value out is then a reference to that array. /// - public static NDarray isposinf(NDarray x, NDarray y = null) + public static NDarray isposinf(this NDarray x, NDarray y = null) { //auto-generated code, do not change var __self__=self; @@ -507,7 +507,7 @@ public static NDarray isposinf(NDarray x, NDarray y = null) /// /// Output array. /// - public static NDarray iscomplex(NDarray x) + public static NDarray iscomplex(this NDarray x) { //auto-generated code, do not change var __self__=self; @@ -559,7 +559,7 @@ public static bool iscomplexobj(object x) /// /// Input array. /// - public static bool isfortran(NDarray a) + public static bool isfortran(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -584,7 +584,7 @@ public static bool isfortran(NDarray a) /// /// Boolean array of same shape as x. /// - public static NDarray isreal(NDarray x) + public static NDarray isreal(this NDarray x) { //auto-generated code, do not change var __self__=self; @@ -684,7 +684,7 @@ public static bool isscalar(object num) /// AND operation on corresponding elements of x1 and x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray logical_and(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray logical_and(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -729,7 +729,7 @@ public static NDarray logical_and(NDarray x2, NDarray x1, NDarray @out = null, N /// OR operation on elements of x1 and x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray logical_or(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray logical_or(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -770,7 +770,7 @@ public static NDarray logical_or(NDarray x2, NDarray x1, NDarray @out = null, ND /// /// This is a scalar if x is a scalar. /// - public static NDarray logical_not(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray logical_not(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -816,7 +816,7 @@ public static NDarray logical_not(NDarray x, NDarray @out = null, NDarray /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray logical_xor(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray logical_xor(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -882,7 +882,7 @@ public static NDarray logical_xor(NDarray x2, NDarray x1, NDarray @out = n /// Returns True if the two arrays are equal within the given /// tolerance; False otherwise. /// - public static bool allclose(NDarray b, NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false) + public static bool allclose(this NDarray b, NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false) { //auto-generated code, do not change var __self__=self; @@ -951,7 +951,7 @@ public static bool allclose(NDarray b, NDarray a, float rtol = 1e-05f, float ato /// If both a and b are scalars, returns a single /// boolean value. /// - public static NDarray isclose(NDarray b, NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false) + public static NDarray isclose(this NDarray b, NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false) { //auto-generated code, do not change var __self__=self; @@ -980,7 +980,7 @@ public static NDarray isclose(NDarray b, NDarray a, float rtol = 1e-05f, float a /// /// Returns True if the arrays are equal. /// - public static bool array_equal(NDarray a2, NDarray a1) + public static bool array_equal(this NDarray a2, NDarray a1) { //auto-generated code, do not change var __self__=self; @@ -1009,7 +1009,7 @@ public static bool array_equal(NDarray a2, NDarray a1) /// /// True if equivalent, False otherwise. /// - public static bool array_equiv(NDarray a2, NDarray a1) + public static bool array_equiv(this NDarray a2, NDarray a1) { //auto-generated code, do not change var __self__=self; @@ -1057,7 +1057,7 @@ public static bool array_equiv(NDarray a2, NDarray a1) /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray greater(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray greater(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1107,7 +1107,7 @@ public static NDarray greater(NDarray x2, NDarray x1, NDarray @out = null, NDarr /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray greater_equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray greater_equal(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1157,7 +1157,7 @@ public static NDarray greater_equal(NDarray x2, NDarray x1, NDarray @out = /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray less(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray less(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1207,7 +1207,7 @@ public static NDarray less(NDarray x2, NDarray x1, NDarray @out = null, NDarray /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray less_equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray less_equal(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1251,7 +1251,7 @@ public static NDarray less_equal(NDarray x2, NDarray x1, NDarray @out = null, ND /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray equal(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1295,7 +1295,7 @@ public static NDarray equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray not_equal(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray not_equal(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.math.gen.cs b/src/Numpy/np.math.gen.cs index a4c7854..84dbded 100644 --- a/src/Numpy/np.math.gen.cs +++ b/src/Numpy/np.math.gen.cs @@ -62,7 +62,7 @@ public static partial class np /// /// This is a scalar if x is a scalar. /// - public static NDarray sin(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray sin(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -116,7 +116,7 @@ public static NDarray sin(NDarray x, NDarray @out = null, NDarray @where = null) /// /// This is a scalar if x is a scalar. /// - public static NDarray cos(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray cos(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -172,7 +172,7 @@ public static NDarray cos(NDarray x, NDarray @out = null, NDarray @where = null) /// /// This is a scalar if x is a scalar. /// - public static NDarray tan(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray tan(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -239,7 +239,7 @@ public static NDarray tan(NDarray x, NDarray @out = null, NDarray @where = null) /// /// This is a scalar if x is a scalar. /// - public static NDarray arcsin(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray arcsin(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -309,7 +309,7 @@ public static NDarray arcsin(NDarray x, NDarray @out = null, NDarray @where = nu /// /// This is a scalar if x is a scalar. /// - public static NDarray arccos(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray arccos(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -376,7 +376,7 @@ public static NDarray arccos(NDarray x, NDarray @out = null, NDarray @where = nu /// /// This is a scalar if x is a scalar. /// - public static NDarray arctan(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray arctan(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -425,7 +425,7 @@ public static NDarray arctan(NDarray x, NDarray @out = null, NDarray @where = nu /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray hypot(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray hypot(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -495,7 +495,7 @@ public static NDarray hypot(NDarray x2, NDarray x1, NDarray @out = null, NDarray /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray arctan2(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray arctan2(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -536,7 +536,7 @@ public static NDarray arctan2(NDarray x1, NDarray x2, NDarray @out = null, NDarr /// /// This is a scalar if x is a scalar. /// - public static NDarray degrees(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray degrees(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -575,7 +575,7 @@ public static NDarray degrees(NDarray x, NDarray @out = null, NDarray @where = n /// /// This is a scalar if x is a scalar. /// - public static NDarray radians(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray radians(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -614,7 +614,7 @@ public static NDarray radians(NDarray x, NDarray @out = null, NDarray @where = n /// /// Output array. /// - public static NDarray unwrap(NDarray p, float? discont = 3.141592653589793f, int? axis = -1) + public static NDarray unwrap(this NDarray p, float? discont = 3.141592653589793f, int? axis = -1) { //auto-generated code, do not change var __self__=self; @@ -657,7 +657,7 @@ public static NDarray unwrap(NDarray p, float? discont = 3.141592653589793f, int /// /// This is a scalar if x is a scalar. /// - public static NDarray deg2rad(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray deg2rad(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -700,7 +700,7 @@ public static NDarray deg2rad(NDarray x, NDarray @out = null, NDarray @where = n /// /// This is a scalar if x is a scalar. /// - public static NDarray rad2deg(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray rad2deg(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -758,7 +758,7 @@ public static NDarray rad2deg(NDarray x, NDarray @out = null, NDarray @where = n /// /// This is a scalar if x is a scalar. /// - public static NDarray sinh(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray sinh(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -799,7 +799,7 @@ public static NDarray sinh(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray cosh(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray cosh(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -848,7 +848,7 @@ public static NDarray cosh(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray tanh(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray tanh(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -907,7 +907,7 @@ public static NDarray tanh(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray arcsinh(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray arcsinh(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -964,7 +964,7 @@ public static NDarray arcsinh(NDarray x, NDarray @out = null, NDarray @where = n /// /// This is a scalar if x is a scalar. /// - public static NDarray arccosh(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray arccosh(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1023,7 +1023,7 @@ public static NDarray arccosh(NDarray x, NDarray @out = null, NDarray @where = n /// /// This is a scalar if x is a scalar. /// - public static NDarray arctanh(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray arctanh(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1082,7 +1082,7 @@ public static NDarray arctanh(NDarray x, NDarray @out = null, NDarray @where = n /// separately.

/// The result of rounding a float is a float. /// - public static NDarray around(NDarray a, int? decimals = 0, NDarray @out = null) + public static NDarray around(this NDarray a, int? decimals = 0, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -1121,7 +1121,7 @@ public static NDarray around(NDarray a, int? decimals = 0, NDarray @out = null) /// /// This is a scalar if x is a scalar. /// - public static NDarray rint(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray rint(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1152,7 +1152,7 @@ public static NDarray rint(NDarray x, NDarray @out = null, NDarray @where = null /// /// The array of rounded numbers /// - public static NDarray fix(NDarray x, NDarray y = null) + public static NDarray fix(this NDarray x, NDarray y = null) { //auto-generated code, do not change var __self__=self; @@ -1200,7 +1200,7 @@ public static NDarray fix(NDarray x, NDarray y = null) /// /// This is a scalar if x is a scalar. /// - public static NDarray floor(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray floor(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1243,7 +1243,7 @@ public static NDarray floor(NDarray x, NDarray @out = null, NDarray @where = nul /// /// This is a scalar if x is a scalar. /// - public static NDarray ceil(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray ceil(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1289,7 +1289,7 @@ public static NDarray ceil(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray trunc(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray trunc(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -1368,7 +1368,7 @@ public static NDarray trunc(NDarray x, NDarray @out = null, NDarray @where = nul /// /// Returns a reference to out if specified. /// - public static NDarray prod(NDarray a, Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) + public static NDarray prod(this NDarray a, Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) { //auto-generated code, do not change var __self__=self; @@ -1451,7 +1451,7 @@ public static NDarray prod(NDarray a, Axis axis = null, Dtype dtype = null, NDar /// If an output array is specified, a reference to /// out is returned. /// - public static NDarray sum(NDarray a, Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) + public static NDarray sum(this NDarray a, Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) { //auto-generated code, do not change var __self__=self; @@ -1518,7 +1518,7 @@ public static NDarray sum(NDarray a, Axis axis = null, Dtype dtype = null, NDarr /// A new array holding the result is returned unless out is /// specified, in which case it is returned. /// - public static NDarray nanprod(NDarray a, Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) + public static NDarray nanprod(this NDarray a, Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -1600,7 +1600,7 @@ public static NDarray nanprod(NDarray a, Axis axis = null, Dtype dtype = null, N /// size as a, and the same shape as a if axis is not None /// or a is a 1-d array. /// - public static NDarray nansum(NDarray a, Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) + public static NDarray nansum(this NDarray a, Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -1652,7 +1652,7 @@ public static NDarray nansum(NDarray a, Axis axis = null, Dtype dtype = null, ND /// A new array holding the result is returned unless out is /// specified, in which case a reference to out is returned. /// - public static NDarray cumprod(NDarray a, int? axis = null, Dtype dtype = null, NDarray @out = null) + public static NDarray cumprod(this NDarray a, int? axis = null, Dtype dtype = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -1708,7 +1708,7 @@ public static NDarray cumprod(NDarray a, int? axis = null, Dtype dtype = null, N /// result has the same size as a, and the same shape as a if /// axis is not None or a is a 1-d array. /// - public static NDarray cumsum(NDarray a, int? axis = null, Dtype dtype = null, NDarray @out = null) + public static NDarray cumsum(this NDarray a, int? axis = null, Dtype dtype = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -1759,7 +1759,7 @@ public static NDarray cumsum(NDarray a, int? axis = null, Dtype dtype = null, ND /// A new array holding the result is returned unless out is /// specified, in which case it is returned. /// - public static NDarray nancumprod(NDarray a, int? axis = null, Dtype dtype = null, NDarray @out = null) + public static NDarray nancumprod(this NDarray a, int? axis = null, Dtype dtype = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -1815,7 +1815,7 @@ public static NDarray nancumprod(NDarray a, int? axis = null, Dtype dtype = null /// size as a, and the same shape as a if axis is not None /// or a is a 1-d array. /// - public static NDarray nancumsum(NDarray a, int? axis = null, Dtype dtype = null, NDarray @out = null) + public static NDarray nancumsum(this NDarray a, int? axis = null, Dtype dtype = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -1894,7 +1894,7 @@ public static NDarray nancumsum(NDarray a, int? axis = null, Dtype dtype = null, /// A notable exception is datetime64, which /// results in a timedelta64 output array. /// - public static NDarray diff(NDarray a, int? n = 1, int? axis = -1, NDarray append = null, NDarray prepend = null) + public static NDarray diff(this NDarray a, int? n = 1, int? axis = -1, NDarray append = null, NDarray prepend = null) { //auto-generated code, do not change var __self__=self; @@ -1932,7 +1932,7 @@ public static NDarray diff(NDarray a, int? n = 1, int? axis = -1, NDarray append /// The differences.

/// Loosely, this is ary.flat[1:] - ary.flat[:-1]. /// - public static NDarray ediff1d(NDarray ary, NDarray to_end = null, NDarray to_begin = null) + public static NDarray ediff1d(this NDarray ary, NDarray to_end = null, NDarray to_begin = null) { //auto-generated code, do not change var __self__=self; @@ -1947,84 +1947,6 @@ public static NDarray ediff1d(NDarray ary, NDarray to_end = null, NDarray to_beg return ToCsharp(py); } - /// - /// Return the gradient of an N-dimensional array.

- /// - /// The gradient is computed using second order accurate central differences - /// in the interior points and either first or second order accurate one-sides - /// (forward or backwards) differences at the boundaries.

- /// - /// The returned gradient hence has the same shape as the input array.

- /// - /// Notes - /// - /// Assuming that (i.e., has at least 3 continuous - /// derivatives) and let be a non-homogeneous stepsize, we - /// minimize the “consistency error” between the true gradient - /// and its estimate from a linear combination of the neighboring grid-points: - /// - /// By substituting and - /// with their Taylor series expansion, this translates into solving - /// the following the linear system: - /// - /// The resulting approximation of is the following: - /// - /// It is worth noting that if - /// (i.e., data are evenly spaced) - /// we find the standard second order approximation: - /// - /// With a similar procedure the forward/backward approximations used for - /// boundaries can be derived.

- /// - /// References - /// - /// - /// An N-dimensional array containing samples of a scalar function. - /// - /// - /// Spacing between f values.

- /// Default unitary spacing for all dimensions.

- /// - /// Spacing can be specified using: - /// - /// If axis is given, the number of varargs must equal the number of axes.

- /// - /// Default: 1. - /// - /// - /// Gradient is calculated using N-th order accurate differences - /// at the boundaries.

- /// Default: 1. - /// - /// - /// Gradient is calculated only along the given axis or axes - /// The default (axis = None) is to calculate the gradient for all the axes - /// of the input array.

- /// axis may be negative, in which case it counts from - /// the last to the first axis. - /// - /// - /// A set of ndarrays (or a single ndarray if there is only one dimension) - /// corresponding to the derivatives of f with respect to each dimension.

- /// - /// Each derivative has the same shape as f. - /// - public static NDarray gradient(NDarray f, NDarray varargs = null, int? edge_order = null, Axis axis = null) - { - //auto-generated code, do not change - var __self__=self; - var pyargs=ToTuple(new object[] - { - f, - }); - var kwargs=new PyDict(); - if (varargs!=null) kwargs["varargs"]=ToPython(varargs); - if (edge_order!=null) kwargs["edge_order"]=ToPython(edge_order); - if (axis!=null) kwargs["axis"]=ToPython(axis); - dynamic py = __self__.InvokeMethod("gradient", pyargs, kwargs); - return ToCsharp(py); - } - /// /// Return the cross product of two (arrays of) vectors.

/// @@ -2072,7 +1994,7 @@ public static NDarray gradient(NDarray f, NDarray varargs = null, int? edge_orde /// /// Vector cross product(s). /// - public static NDarray cross(NDarray a, NDarray b, int? axisa = -1, int? axisb = -1, int? axisc = -1, int? axis = null) + public static NDarray cross(this NDarray a, NDarray b, int? axisa = -1, int? axisb = -1, int? axisc = -1, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -2126,7 +2048,7 @@ public static NDarray cross(NDarray a, NDarray b, int? axisa = -1, int? axisb = /// /// Definite integral as approximated by trapezoidal rule. /// - public static float trapz(NDarray y, NDarray x = null, float? dx = 1.0f, int? axis = -1) + public static float trapz(this NDarray y, NDarray x = null, float? dx = 1.0f, int? axis = -1) { //auto-generated code, do not change var __self__=self; @@ -2183,7 +2105,7 @@ public static float trapz(NDarray y, NDarray x = null, float? dx = 1.0f, int? ax /// /// This is a scalar if x is a scalar. /// - public static NDarray exp(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray exp(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2227,7 +2149,7 @@ public static NDarray exp(NDarray x, NDarray @out = null, NDarray @where = null) /// /// This is a scalar if x is a scalar. /// - public static NDarray expm1(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray expm1(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2268,7 +2190,7 @@ public static NDarray expm1(NDarray x, NDarray @out = null, NDarray @where = nul /// /// This is a scalar if x is a scalar. /// - public static NDarray exp2(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray exp2(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2332,7 +2254,7 @@ public static NDarray exp2(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray log(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray log(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2393,7 +2315,7 @@ public static NDarray log(NDarray x, NDarray @out = null, NDarray @where = null) /// /// This is a scalar if x is a scalar. /// - public static NDarray log10(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray log10(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2450,7 +2372,7 @@ public static NDarray log10(NDarray x, NDarray @out = null, NDarray @where = nul /// /// This is a scalar if x is a scalar. /// - public static NDarray log2(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray log2(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2514,7 +2436,7 @@ public static NDarray log2(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray log1p(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray log1p(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2567,7 +2489,7 @@ public static NDarray log1p(NDarray x, NDarray @out = null, NDarray @where = nul /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray logaddexp(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray logaddexp(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2620,7 +2542,7 @@ public static NDarray logaddexp(NDarray x2, NDarray x1, NDarray @out = null, NDa /// Base-2 logarithm of 2**x1 + 2**x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray logaddexp2(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray logaddexp2(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2663,7 +2585,7 @@ public static NDarray logaddexp2(NDarray x2, NDarray x1, NDarray @out = null, ND /// /// sinc(x), which has the same shape as the input. /// - public static NDarray sinc(NDarray x) + public static NDarray sinc(this NDarray x) { //auto-generated code, do not change var __self__=self; @@ -2700,7 +2622,7 @@ public static NDarray sinc(NDarray x) /// /// This is a scalar if x is a scalar. /// - public static NDarray signbit(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray signbit(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2746,7 +2668,7 @@ public static NDarray signbit(NDarray x, NDarray @out = null, NDarray @where = n /// The values of x1 with the sign of x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray copysign(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray copysign(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2806,7 +2728,7 @@ public static NDarray copysign(NDarray x1, NDarray x2, NDarray @out = null, NDar /// Integer exponents of 2. /// This is a scalar if x is a scalar. /// - public static (NDarray, NDarray) frexp(NDarray x, NDarray out1 = null, NDarray out2 = null, NDarray @out = null, NDarray @where = null) + public static (NDarray, NDarray) frexp(this NDarray x, NDarray out1 = null, NDarray out2 = null, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2859,7 +2781,7 @@ public static (NDarray, NDarray) frexp(NDarray x, NDarray out1 = null, NDarray o /// The result of x1 * 2**x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray ldexp(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray ldexp(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2901,7 +2823,7 @@ public static NDarray ldexp(NDarray x1, NDarray x2, NDarray @out = null, NDarray /// The next representable values of x1 in the direction of x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray nextafter(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray nextafter(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2950,7 +2872,7 @@ public static NDarray nextafter(NDarray x1, NDarray x2, NDarray @out = null, NDa /// /// This is a scalar if x is a scalar. /// - public static NDarray spacing(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray spacing(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -2978,7 +2900,7 @@ public static NDarray spacing(NDarray x, NDarray @out = null, NDarray @where = n /// The lowest common multiple of the absolute value of the inputs /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray lcm(NDarray x2, NDarray x1) + public static NDarray lcm(this NDarray x2, NDarray x1) { //auto-generated code, do not change var __self__=self; @@ -3005,7 +2927,7 @@ public static NDarray lcm(NDarray x2, NDarray x1) /// The greatest common divisor of the absolute value of the inputs /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray gcd(NDarray x2, NDarray x1) + public static NDarray gcd(this NDarray x2, NDarray x1) { //auto-generated code, do not change var __self__=self; @@ -3056,7 +2978,7 @@ public static NDarray gcd(NDarray x2, NDarray x1) /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray @add(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray @add(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3105,7 +3027,7 @@ public static NDarray @add(NDarray x2, NDarray x1, NDarray @out = null, NDarray /// /// This is a scalar if x is a scalar. /// - public static NDarray reciprocal(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray reciprocal(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3136,7 +3058,7 @@ public static NDarray reciprocal(NDarray x, NDarray @out = null, NDarray @where /// /// This is a scalar if x is a scalar. /// - public static NDarray positive(NDarray x) + public static NDarray positive(this NDarray x) { //auto-generated code, do not change var __self__=self; @@ -3173,7 +3095,7 @@ public static NDarray positive(NDarray x) /// /// This is a scalar if x is a scalar. /// - public static NDarray negative(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray negative(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3219,7 +3141,7 @@ public static NDarray negative(NDarray x, NDarray @out = null, NDarray @where = /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray multiply(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray multiply(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3278,7 +3200,7 @@ public static NDarray multiply(NDarray x2, NDarray x1, NDarray @out = null, NDar /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray divide(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray divide(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3325,7 +3247,7 @@ public static NDarray divide(NDarray x1, NDarray x2, NDarray @out = null, NDarra /// The bases in x1 raised to the exponents in x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray power(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray power(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3372,7 +3294,7 @@ public static NDarray power(NDarray x1, NDarray x2, NDarray @out = null, NDarray /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray subtract(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray subtract(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3431,7 +3353,7 @@ public static NDarray subtract(NDarray x2, NDarray x1, NDarray @out = null, NDar /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray true_divide(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray true_divide(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3477,7 +3399,7 @@ public static NDarray true_divide(NDarray x1, NDarray x2, NDarray @out = null, N /// y = floor(x1/x2) /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray floor_divide(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray floor_divide(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3528,7 +3450,7 @@ public static NDarray floor_divide(NDarray x1, NDarray x2, NDarray @out = null, /// The bases in x1 raised to the exponents in x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray float_power(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray float_power(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3585,7 +3507,7 @@ public static NDarray float_power(NDarray x1, NDarray x2, NDarray @out = null, N /// The remainder of the division of x1 by x2. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray fmod(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray fmod(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3639,7 +3561,7 @@ public static NDarray fmod(NDarray x1, NDarray x2, NDarray @out = null, NDarray /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray mod(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray mod(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3690,7 +3612,7 @@ public static NDarray mod(NDarray x1, NDarray x2, NDarray @out = null, NDarray @ /// Integral part of x. /// This is a scalar if x is a scalar. /// - public static (NDarray, NDarray) modf(NDarray x, NDarray @out = null, NDarray @where = null) + public static (NDarray, NDarray) modf(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3743,7 +3665,7 @@ public static (NDarray, NDarray) modf(NDarray x, NDarray @out = null, NDarray @w /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray remainder(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray remainder(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3795,7 +3717,7 @@ public static NDarray remainder(NDarray x1, NDarray x2, NDarray @out = null, NDa /// Element-wise remainder from floor division. /// This is a scalar if both x1 and x2 are scalars. /// - public static (NDarray, NDarray) divmod(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static (NDarray, NDarray) divmod(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3824,7 +3746,7 @@ public static (NDarray, NDarray) divmod(NDarray x1, NDarray x2, NDarray @out = n /// The counterclockwise angle from the positive real axis on /// the complex plane, with dtype as numpy.float64. /// - public static NDarray angle(NDarray z, bool? deg = false) + public static NDarray angle(this NDarray z, bool? deg = false) { //auto-generated code, do not change var __self__=self; @@ -3851,7 +3773,7 @@ public static NDarray angle(NDarray z, bool? deg = false) /// If val has complex elements, the /// returned type is float. /// - public static NDarray real(NDarray val) + public static NDarray real(this NDarray val) { //auto-generated code, do not change var __self__=self; @@ -3877,7 +3799,7 @@ public static NDarray real(NDarray val) /// If val has complex /// elements, the returned type is float. /// - public static NDarray imag(NDarray val) + public static NDarray imag(this NDarray val) { //auto-generated code, do not change var __self__=self; @@ -3917,7 +3839,7 @@ public static NDarray imag(NDarray val) /// /// This is a scalar if x is a scalar. /// - public static NDarray conj(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray conj(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -3967,7 +3889,7 @@ public static NDarray conj(NDarray x, NDarray @out = null, NDarray @where = null /// /// Discrete, linear convolution of a and v. /// - public static NDarray convolve(NDarray a, NDarray v, string mode = "full") + public static NDarray convolve(this NDarray a, NDarray v, string mode = "full") { //auto-generated code, do not change var __self__=self; @@ -4023,7 +3945,7 @@ public static NDarray convolve(NDarray a, NDarray v, string mode = "full") /// < a_min are replaced with a_min, and those > a_max /// with a_max. /// - public static NDarray clip(NDarray a, NDarray a_min, NDarray a_max, NDarray @out = null) + public static NDarray clip(this NDarray a, NDarray a_min, NDarray a_max, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -4079,7 +4001,7 @@ public static NDarray clip(NDarray a, NDarray a_min, NDarray a_max, NDarray @out /// /// This is a scalar if x is a scalar. /// - public static NDarray sqrt(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray sqrt(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4121,7 +4043,7 @@ public static NDarray sqrt(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray cbrt(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray cbrt(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4160,7 +4082,7 @@ public static NDarray cbrt(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray square(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray square(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4203,7 +4125,7 @@ public static NDarray square(NDarray x, NDarray @out = null, NDarray @where = nu /// absolute value is . /// This is a scalar if x is a scalar. /// - public static NDarray absolute(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray absolute(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4249,7 +4171,7 @@ public static NDarray absolute(NDarray x, NDarray @out = null, NDarray @where = /// /// This is a scalar if x is a scalar. /// - public static NDarray fabs(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray fabs(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4304,7 +4226,7 @@ public static NDarray fabs(NDarray x, NDarray @out = null, NDarray @where = null /// /// This is a scalar if x is a scalar. /// - public static NDarray sign(NDarray x, NDarray @out = null, NDarray @where = null) + public static NDarray sign(this NDarray x, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4353,7 +4275,7 @@ public static NDarray sign(NDarray x, NDarray @out = null, NDarray @where = null /// The output array, element-wise Heaviside step function of x1. /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray heaviside(NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) + public static NDarray heaviside(this NDarray x1, NDarray x2, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4417,7 +4339,7 @@ public static NDarray heaviside(NDarray x1, NDarray x2, NDarray @out = null, NDa /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray maximum(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray maximum(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4481,7 +4403,7 @@ public static NDarray maximum(NDarray x2, NDarray x1, NDarray @out = null, NDarr /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray minimum(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray minimum(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4544,7 +4466,7 @@ public static NDarray minimum(NDarray x2, NDarray x1, NDarray @out = null, NDarr /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray fmax(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray fmax(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4607,7 +4529,7 @@ public static NDarray fmax(NDarray x2, NDarray x1, NDarray @out = null, NDarray /// /// This is a scalar if both x1 and x2 are scalars. /// - public static NDarray fmin(NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) + public static NDarray fmin(this NDarray x2, NDarray x1, NDarray @out = null, NDarray @where = null) { //auto-generated code, do not change var __self__=self; @@ -4657,7 +4579,7 @@ public static NDarray fmin(NDarray x2, NDarray x1, NDarray @out = null, NDarray /// If copy is False, this may /// be x itself. /// - public static NDarray nan_to_num(NDarray x, bool? copy = true) + public static NDarray nan_to_num(this NDarray x, bool? copy = true) { //auto-generated code, do not change var __self__=self; @@ -4696,7 +4618,7 @@ public static NDarray nan_to_num(NDarray x, bool? copy = true) /// If a /// has complex elements, the returned type is float. /// - public static NDarray real_if_close(NDarray a, float tol = 100) + public static NDarray real_if_close(this NDarray a, float tol = 100) { //auto-generated code, do not change var __self__=self; @@ -4753,7 +4675,7 @@ public static NDarray real_if_close(NDarray a, float tol = 100) /// /// The interpolated values, same shape as x. /// - public static float or complex (corresponding to fp) or ndarray interp(NDarray x, 1-D sequence of floats xp, 1-D sequence of float or complex fp, optional float or complex corresponding to fp left = null, optional float or complex corresponding to fp right = null, None or float period = null) + public static float or complex (corresponding to fp) or ndarray interp(this NDarray x, 1-D sequence of floats xp, 1-D sequence of float or complex fp, optional float or complex corresponding to fp left = null, optional float or complex corresponding to fp right = null, None or float period = null) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.module.gen.cs b/src/Numpy/np.module.gen.cs index 083a976..eaf6da8 100644 --- a/src/Numpy/np.module.gen.cs +++ b/src/Numpy/np.module.gen.cs @@ -18,10 +18,15 @@ namespace Numpy { public static partial class np { + static np() + { + ReInitializeLazySelf(); + } public static PyObject self => _lazy_self.Value; - private static Lazy _lazy_self = new Lazy(() => + private static Lazy _lazy_self = default; + private static void ReInitializeLazySelf() => _lazy_self = new Lazy(() => { try { @@ -41,8 +46,9 @@ private static PyObject InstallAndImport(bool force = false) Installer.SetupPython(force).Wait(); #endif #if PYTHON_INCLUDED - Installer.InstallWheel(typeof(np).Assembly, "numpy-1.16.3-cp37-cp37m-win_amd64.whl").Wait(); + Installer.InstallWheel(typeof(np).Assembly, "numpy-1.23.5-cp311-cp311-win_amd64.whl", force).Wait(); #endif + PythonEngine.AddShutdownHandler(() => ReInitializeLazySelf()); PythonEngine.Initialize(); var mod = Py.Import("numpy"); return mod; @@ -70,14 +76,14 @@ private static PyTuple ToTuple(Array input) } //auto-generated - private static PyObject ToPython(object obj) + internal static PyObject ToPython(object obj) { if (obj == null) return Runtime.None; switch (obj) { // basic types case int o: return new PyInt(o); - case long o: return new PyLong(o); + case long o: return new PyInt(o); case float o: return new PyFloat(o); case double o: return new PyFloat(o); case string o: return new PyString(o); @@ -96,7 +102,7 @@ private static PyObject ToPython(object obj) } //auto-generated - private static T ToCsharp(dynamic pyobj) + internal static T ToCsharp(dynamic pyobj) { switch (typeof(T).Name) { @@ -125,20 +131,29 @@ private static T ToCsharp(dynamic pyobj) return (T) (object) rv; case "Matrix": return (T)(object)new Matrix(pyobj); default: + var pyClass = $"{pyobj.__class__}"; + if (pyClass == "") + { + return (T)(object)pyobj.ToString(); + } + if (pyClass.StartsWith("(); + } try { return pyobj.As(); } catch (Exception e) { - throw new NotImplementedException($"conversion from {typeof(T).Name} to {pyobj.__class__} not implemented", e); + throw new NotImplementedException($"conversion from {pyobj.__class__} to {typeof(T).Name} not implemented", e); return default(T); } } } //auto-generated - private static T SharpToSharp(object obj) + internal static T SharpToSharp(object obj) { if (obj == null) return default(T); switch (obj) diff --git a/src/Numpy/np.other.gen.cs b/src/Numpy/np.other.gen.cs new file mode 100644 index 0000000..3e4fbdf --- /dev/null +++ b/src/Numpy/np.other.gen.cs @@ -0,0 +1,57 @@ +// Copyright (c) 2020 by Meinrad Recheis (Member of SciSharp) +// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion + +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using Python.Runtime; +using Numpy.Models; +#if PYTHON_INCLUDED +using Python.Included; +#endif + +namespace Numpy +{ + public static partial class np + { + + /// + /// Return the roots of a polynomial with coefficients given in p.

+ /// + /// The values in the rank-1 array p are coefficients of a polynomial.

+ /// + /// If the length of p is n+1 then the polynomial is described by: + /// + /// Notes + /// + /// The algorithm relies on computing the eigenvalues of the + /// companion matrix [1].

+ /// + /// References + /// + /// + /// Rank-1 array of polynomial coefficients. + /// + /// + /// An array containing the roots of the polynomial. + /// + public static NDarray roots(this NDarray p) + { + //auto-generated code, do not change + var __self__=self; + var pyargs=ToTuple(new object[] + { + p, + }); + var kwargs=new PyDict(); + dynamic py = __self__.InvokeMethod("roots", pyargs, kwargs); + return ToCsharp(py); + } + + + } +} diff --git a/src/Numpy/np.padding.gen.cs b/src/Numpy/np.padding.gen.cs index f27ecf0..dd5083b 100644 --- a/src/Numpy/np.padding.gen.cs +++ b/src/Numpy/np.padding.gen.cs @@ -110,7 +110,7 @@ public static partial class np /// Padded array of rank equal to array with shape increased /// according to pad_width. /// - public static NDarray pad(NDarray array, NDarray pad_width, string mode, int[] stat_length = null, int[] constant_values = null, int[] end_values = null, string reflect_type = null) + public static NDarray pad(this NDarray array, NDarray pad_width, string mode, int[] stat_length = null, int[] constant_values = null, int[] end_values = null, string reflect_type = null) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.set.gen.cs b/src/Numpy/np.set.gen.cs index 3970eff..4620157 100644 --- a/src/Numpy/np.set.gen.cs +++ b/src/Numpy/np.set.gen.cs @@ -61,7 +61,7 @@ public static partial class np /// /// The values ar1[in1d] are in ar2. /// - public static NDarray in1d(NDarray ar1, NDarray ar2, bool? assume_unique = false, bool? invert = false) + public static NDarray in1d(this NDarray ar1, NDarray ar2, bool? assume_unique = false, bool? invert = false) { //auto-generated code, do not change var __self__=self; @@ -113,7 +113,7 @@ public static NDarray in1d(NDarray ar1, NDarray ar2, bool? assume_unique = false /// The indices of the first occurrences of the common values in ar2. /// Only provided if return_indices is True. /// - public static (NDarray, NDarray, NDarray) intersect1d(NDarray ar2, NDarray ar1, bool assume_unique = false, bool return_indices = false) + public static (NDarray, NDarray, NDarray) intersect1d(this NDarray ar2, NDarray ar1, bool assume_unique = false, bool return_indices = false) { //auto-generated code, do not change var __self__=self; @@ -180,7 +180,7 @@ public static (NDarray, NDarray, NDarray) intersect1d(NDarray ar2, NDarray ar1, /// The values element[isin] /// are in test_elements. /// - public static NDarray isin(NDarray element, NDarray test_elements, bool? assume_unique = false, bool? invert = false) + public static NDarray isin(this NDarray element, NDarray test_elements, bool? assume_unique = false, bool? invert = false) { //auto-generated code, do not change var __self__=self; @@ -217,7 +217,7 @@ public static NDarray isin(NDarray element, NDarray test_elements, bool? assume_ /// is sorted when assume_unique=False, but otherwise only sorted /// if the input is sorted. /// - public static NDarray setdiff1d(NDarray ar1, NDarray ar2, bool assume_unique = false) + public static NDarray setdiff1d(this NDarray ar1, NDarray ar2, bool assume_unique = false) { //auto-generated code, do not change var __self__=self; @@ -253,7 +253,7 @@ public static NDarray setdiff1d(NDarray ar1, NDarray ar2, bool assume_unique = f /// Sorted 1D array of unique values that are in only one of the input /// arrays. /// - public static NDarray setxor1d(NDarray ar2, NDarray ar1, bool assume_unique = false) + public static NDarray setxor1d(this NDarray ar2, NDarray ar1, bool assume_unique = false) { //auto-generated code, do not change var __self__=self; @@ -285,7 +285,7 @@ public static NDarray setxor1d(NDarray ar2, NDarray ar1, bool assume_unique = fa /// /// Unique, sorted union of the input arrays. /// - public static NDarray union1d(NDarray ar2, NDarray ar1) + public static NDarray union1d(this NDarray ar2, NDarray ar1) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.sorting.gen.cs b/src/Numpy/np.sorting.gen.cs index 88ef4a9..1cc4cf2 100644 --- a/src/Numpy/np.sorting.gen.cs +++ b/src/Numpy/np.sorting.gen.cs @@ -90,7 +90,7 @@ public static partial class np /// /// Array of the same type and shape as a. /// - public static NDarray sort(NDarray a, int? axis = -1, string kind = "quicksort", string order = null) + public static NDarray sort(this NDarray a, int? axis = -1, string kind = "quicksort", string order = null) { //auto-generated code, do not change var __self__=self; @@ -133,7 +133,7 @@ public static NDarray sort(NDarray a, int? axis = -1, string kind = "quicksort", /// /// Array of indices that sort the keys along the specified axis. /// - public static NDarray lexsort(NDarray keys, int? axis = -1) + public static NDarray lexsort(this NDarray keys, int? axis = -1) { //auto-generated code, do not change var __self__=self; @@ -191,7 +191,7 @@ public static NDarray lexsort(NDarray keys, int? axis = -1) /// More generally, np.take_along_axis(a, index_array, axis=a) always /// yields the sorted a, irrespective of dimensionality. /// - public static NDarray argsort(NDarray a, int? axis = -1, string kind = "quicksort", string order = null) + public static NDarray argsort(this NDarray a, int? axis = -1, string kind = "quicksort", string order = null) { //auto-generated code, do not change var __self__=self; @@ -258,7 +258,7 @@ public static void sort(int? axis = -1, string kind = null, string order = null) /// /// Array of the same type and shape as a. /// - public static NDarray msort(NDarray a) + public static NDarray msort(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -280,7 +280,7 @@ public static NDarray msort(NDarray a) /// /// Always returns a sorted complex array. /// - public static NDarray sort_complex(NDarray a) + public static NDarray sort_complex(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -363,7 +363,7 @@ public static NDarray sort_complex(NDarray a) /// /// Array of the same type and shape as a. /// - public static NDarray partition(NDarray a, int[] kth, int? axis = -1, string kind = "introselect", string order = null) + public static NDarray partition(this NDarray a, int[] kth, int? axis = -1, string kind = "introselect", string order = null) { //auto-generated code, do not change var __self__=self; @@ -431,7 +431,7 @@ public static NDarray partition(NDarray a, int[] kth, int? axis = -1, string kin /// More generally, np.take_along_axis(a, index_array, axis=a) always /// yields the partitioned a, irrespective of dimensionality. /// - public static NDarray argpartition(NDarray a, int[] kth, int? axis = -1, string kind = "introselect", string order = null) + public static NDarray argpartition(this NDarray a, int[] kth, int? axis = -1, string kind = "introselect", string order = null) { //auto-generated code, do not change var __self__=self; @@ -473,7 +473,7 @@ public static NDarray argpartition(NDarray a, int[] kth, int? axis = -1, string /// It has the same shape as a.shape /// with the dimension along axis removed. /// - public static NDarray argmax(NDarray a, int? axis = null, NDarray @out = null) + public static NDarray argmax(this NDarray a, int? axis = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -505,7 +505,7 @@ public static NDarray argmax(NDarray a, int? axis = null, NDarray @out = null) /// /// An array of indices or a single index value. /// - public static NDarray nanargmax(NDarray a, int? axis = null) + public static NDarray nanargmax(this NDarray a, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -544,7 +544,7 @@ public static NDarray nanargmax(NDarray a, int? axis = null) /// It has the same shape as a.shape /// with the dimension along axis removed. /// - public static NDarray argmin(NDarray a, int? axis = null, NDarray @out = null) + public static NDarray argmin(this NDarray a, int? axis = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -576,7 +576,7 @@ public static NDarray argmin(NDarray a, int? axis = null, NDarray @out = null) /// /// An array of indices or a single index value. /// - public static NDarray nanargmin(NDarray a, int? axis = null) + public static NDarray nanargmin(this NDarray a, int? axis = null) { //auto-generated code, do not change var __self__=self; @@ -608,7 +608,7 @@ public static NDarray nanargmin(NDarray a, int? axis = null) /// Indices of elements that are non-zero.

/// Indices are grouped by element. /// - public static NDarray argwhere(NDarray a) + public static NDarray argwhere(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -633,7 +633,7 @@ public static NDarray argwhere(NDarray a) /// Output array, containing the indices of the elements of a.ravel() /// that are non-zero. /// - public static NDarray flatnonzero(NDarray a) + public static NDarray flatnonzero(this NDarray a) { //auto-generated code, do not change var __self__=self; @@ -691,7 +691,7 @@ public static NDarray flatnonzero(NDarray a) /// /// Array of insertion points with the same shape as v. /// - public static NDarray searchsorted(NDarray a, NDarray v, string side = "left", NDarray sorter = null) + public static NDarray searchsorted(this NDarray a, NDarray v, string side = "left", NDarray sorter = null) { //auto-generated code, do not change var __self__=self; @@ -726,7 +726,7 @@ public static NDarray searchsorted(NDarray a, NDarray v, string side = "lef /// /// Rank 1 array of values from arr where condition is True. /// - public static NDarray extract(NDarray condition, NDarray arr) + public static NDarray extract(this NDarray condition, NDarray arr) { //auto-generated code, do not change var __self__=self; @@ -769,7 +769,7 @@ public static NDarray extract(NDarray condition, NDarray arr) /// Otherwise, the total number of non-zero values in the array /// is returned. /// - public static NDarray count_nonzero(NDarray a, Axis axis) + public static NDarray count_nonzero(this NDarray a, Axis axis) { //auto-generated code, do not change var __self__=self; @@ -806,7 +806,7 @@ public static NDarray count_nonzero(NDarray a, Axis axis) /// Otherwise, the total number of non-zero values in the array /// is returned. /// - public static int count_nonzero(NDarray a) + public static int count_nonzero(this NDarray a) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.staticstics.gen.cs b/src/Numpy/np.staticstics.gen.cs index 94b0410..eac91eb 100644 --- a/src/Numpy/np.staticstics.gen.cs +++ b/src/Numpy/np.staticstics.gen.cs @@ -77,7 +77,7 @@ public static partial class np /// If axis is given, the result is an array of dimension /// a.ndim - 1. /// - public static NDarray amin(NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) + public static NDarray amin(this NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) { //auto-generated code, do not change var __self__=self; @@ -152,7 +152,7 @@ public static NDarray amin(NDarray a, Axis axis = null, NDarray @out = null, boo /// If axis is given, the result is an array of dimension /// a.ndim - 1. /// - public static NDarray amax(NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) + public static NDarray amax(this NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null) { //auto-generated code, do not change var __self__=self; @@ -224,7 +224,7 @@ public static NDarray amax(NDarray a, Axis axis = null, NDarray @out = null, boo /// scalar is returned.

/// The same dtype as a is returned. /// - public static NDarray nanmin(NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null) + public static NDarray nanmin(this NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -295,7 +295,7 @@ public static NDarray nanmin(NDarray a, Axis axis = null, NDarray @out = null, b /// returned.

/// The same dtype as a is returned. /// - public static NDarray nanmax(NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null) + public static NDarray nanmax(this NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -352,7 +352,7 @@ public static NDarray nanmax(NDarray a, Axis axis = null, NDarray @out = null, b /// A new array holding the result, unless out was /// specified, in which case a reference to out is returned. /// - public static NDarray ptp(NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null) + public static NDarray ptp(this NDarray a, Axis axis = null, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -436,7 +436,7 @@ public static NDarray ptp(NDarray a, Axis axis = null, NDarray @out = null, bool /// If out is specified, that array is /// returned instead. /// - public static NDarray percentile(NDarray a, NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = false) + public static NDarray percentile(this NDarray a, NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = false) { //auto-generated code, do not change var __self__=self; @@ -511,7 +511,7 @@ public static NDarray percentile(NDarray a, NDarray q, Axis axis, /// If out is specified, that array is /// returned instead. /// - public static double percentile(NDarray a, NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") + public static double percentile(this NDarray a, NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") { //auto-generated code, do not change var __self__=self; @@ -605,7 +605,7 @@ public static double percentile(NDarray a, NDarray q, NDarray @out = null /// If out is specified, that array is /// returned instead. /// - public static NDarray nanpercentile(NDarray a, NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = null) + public static NDarray nanpercentile(this NDarray a, NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -682,7 +682,7 @@ public static NDarray nanpercentile(NDarray a, NDarray q, Axis ax /// If out is specified, that array is /// returned instead. /// - public static double nanpercentile(NDarray a, NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") + public static double nanpercentile(this NDarray a, NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") { //auto-generated code, do not change var __self__=self; @@ -767,7 +767,7 @@ public static double nanpercentile(NDarray a, NDarray q, NDarray @out = n /// If out is specified, that array is /// returned instead. /// - public static NDarray quantile(NDarray a, NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = false) + public static NDarray quantile(this NDarray a, NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = false) { //auto-generated code, do not change var __self__=self; @@ -842,7 +842,7 @@ public static NDarray quantile(NDarray a, NDarray q, Axis axis, N /// If out is specified, that array is /// returned instead. /// - public static double quantile(NDarray a, NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") + public static double quantile(this NDarray a, NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") { //auto-generated code, do not change var __self__=self; @@ -925,7 +925,7 @@ public static double quantile(NDarray a, NDarray q, NDarray @out = null, /// If out is specified, that array is /// returned instead. /// - public static NDarray nanquantile(NDarray a, NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = null) + public static NDarray nanquantile(this NDarray a, NDarray q, Axis axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -991,7 +991,7 @@ public static NDarray nanquantile(NDarray a, NDarray q, Axis axis /// If out is specified, that array is /// returned instead. /// - public static double nanquantile(NDarray a, NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") + public static double nanquantile(this NDarray a, NDarray q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear") { //auto-generated code, do not change var __self__=self; @@ -1065,7 +1065,7 @@ public static double nanquantile(NDarray a, NDarray q, NDarray @out = nul /// If out is specified, that array is /// returned instead. /// - public static NDarray median(NDarray a, Axis axis, NDarray @out = null, bool? overwrite_input = false, bool? keepdims = false) + public static NDarray median(this NDarray a, Axis axis, NDarray @out = null, bool? overwrite_input = false, bool? keepdims = false) { //auto-generated code, do not change var __self__=self; @@ -1126,7 +1126,7 @@ public static NDarray median(NDarray a, Axis axis, NDarray @out = null, /// If out is specified, that array is /// returned instead. /// - public static double median(NDarray a, NDarray @out = null, bool? overwrite_input = false) + public static double median(this NDarray a, NDarray @out = null, bool? overwrite_input = false) { //auto-generated code, do not change var __self__=self; @@ -1197,7 +1197,7 @@ public static double median(NDarray a, NDarray @out = null, bool? overwrite_inpu /// integral, the previous rules still applies but the result dtype will /// at least be float64. /// - public static NDarray average(NDarray a, Axis axis, NDarray weights = null, bool? returned = false) + public static NDarray average(this NDarray a, Axis axis, NDarray weights = null, bool? returned = false) { //auto-generated code, do not change var __self__=self; @@ -1258,7 +1258,7 @@ public static NDarray average(NDarray a, Axis axis, NDarray weights = nu /// integral, the previous rules still applies but the result dtype will /// at least be float64. /// - public static double average(NDarray a, NDarray weights = null, bool? returned = false) + public static double average(this NDarray a, NDarray weights = null, bool? returned = false) { //auto-generated code, do not change var __self__=self; @@ -1342,7 +1342,7 @@ public static double average(NDarray a, NDarray weights = null, bool? returned = /// If out=None, returns a new array containing the mean values, /// otherwise a reference to the output array is returned. /// - public static NDarray mean(NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) + public static NDarray mean(this NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -1407,7 +1407,7 @@ public static NDarray mean(NDarray a, Axis axis, Dtype dtype = null, NDa /// If out=None, returns a new array containing the mean values, /// otherwise a reference to the output array is returned. /// - public static double mean(NDarray a, Dtype dtype = null, NDarray @out = null) + public static double mean(this NDarray a, Dtype dtype = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -1507,7 +1507,7 @@ public static double mean(NDarray a, Dtype dtype = null, NDarray @out = null) /// If out is None, return a new array containing the standard deviation, /// otherwise return a reference to the output array. /// - public static NDarray std(NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) + public static NDarray std(this NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -1589,7 +1589,7 @@ public static NDarray std(NDarray a, Axis axis, Dtype dtype = null, NDar /// If out is None, return a new array containing the standard deviation, /// otherwise return a reference to the output array. /// - public static double std(NDarray a, Dtype dtype = null, NDarray @out = null, int? ddof = 0) + public static double std(this NDarray a, Dtype dtype = null, NDarray @out = null, int? ddof = 0) { //auto-generated code, do not change var __self__=self; @@ -1687,7 +1687,7 @@ public static double std(NDarray a, Dtype dtype = null, NDarray @out = null, int /// If out=None, returns a new array containing the variance; /// otherwise, a reference to the output array is returned. /// - public static NDarray @var(NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) + public static NDarray @var(this NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -1766,7 +1766,7 @@ public static NDarray @var(NDarray a, Axis axis, Dtype dtype = null, NDa /// If out=None, returns a new array containing the variance; /// otherwise, a reference to the output array is returned. /// - public static double @var(NDarray a, Dtype dtype = null, NDarray @out = null, int? ddof = 0) + public static double @var(this NDarray a, Dtype dtype = null, NDarray @out = null, int? ddof = 0) { //auto-generated code, do not change var __self__=self; @@ -1846,7 +1846,7 @@ public static double @var(NDarray a, Dtype dtype = null, NDarray @out = null, in /// If out is specified, that array is /// returned instead. /// - public static NDarray nanmedian(NDarray a, Axis axis, NDarray @out = null, bool? overwrite_input = false, bool? keepdims = null) + public static NDarray nanmedian(this NDarray a, Axis axis, NDarray @out = null, bool? overwrite_input = false, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -1907,7 +1907,7 @@ public static NDarray nanmedian(NDarray a, Axis axis, NDarray @out = nul /// If out is specified, that array is /// returned instead. /// - public static double nanmedian(NDarray a, NDarray @out = null, bool? overwrite_input = false) + public static double nanmedian(this NDarray a, NDarray @out = null, bool? overwrite_input = false) { //auto-generated code, do not change var __self__=self; @@ -1987,7 +1987,7 @@ public static double nanmedian(NDarray a, NDarray @out = null, bool? overwrite_i /// Nan is /// returned for slices that contain only NaNs. /// - public static NDarray nanmean(NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) + public static NDarray nanmean(this NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -2052,7 +2052,7 @@ public static NDarray nanmean(NDarray a, Axis axis, Dtype dtype = null, /// Nan is /// returned for slices that contain only NaNs. /// - public static double nanmean(NDarray a, Dtype dtype = null, NDarray @out = null) + public static double nanmean(this NDarray a, Dtype dtype = null, NDarray @out = null) { //auto-generated code, do not change var __self__=self; @@ -2156,7 +2156,7 @@ public static double nanmean(NDarray a, Dtype dtype = null, NDarray @out = null) /// ddof is >= the number of non-NaN elements in a slice or the slice /// contains only NaNs, then the result for that slice is NaN. /// - public static NDarray nanstd(NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) + public static NDarray nanstd(this NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -2246,7 +2246,7 @@ public static NDarray nanstd(NDarray a, Axis axis, Dtype dtype = null, N /// ddof is >= the number of non-NaN elements in a slice or the slice /// contains only NaNs, then the result for that slice is NaN. /// - public static double nanstd(NDarray a, Dtype dtype = null, NDarray @out = null, int? ddof = 0) + public static double nanstd(this NDarray a, Dtype dtype = null, NDarray @out = null, int? ddof = 0) { //auto-generated code, do not change var __self__=self; @@ -2343,7 +2343,7 @@ public static double nanstd(NDarray a, Dtype dtype = null, NDarray @out = null, /// number of non-NaN elements in a slice or the slice contains only /// NaNs, then the result for that slice is NaN. /// - public static NDarray nanvar(NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) + public static NDarray nanvar(this NDarray a, Axis axis, Dtype dtype = null, NDarray @out = null, int? ddof = 0, bool? keepdims = null) { //auto-generated code, do not change var __self__=self; @@ -2431,7 +2431,7 @@ public static NDarray nanvar(NDarray a, Axis axis, Dtype dtype = null, N /// number of non-NaN elements in a slice or the slice contains only /// NaNs, then the result for that slice is NaN. /// - public static double nanvar(NDarray a, Dtype dtype = null, NDarray @out = null, int? ddof = 0) + public static double nanvar(this NDarray a, Dtype dtype = null, NDarray @out = null, int? ddof = 0) { //auto-generated code, do not change var __self__=self; @@ -2495,7 +2495,7 @@ public static double nanvar(NDarray a, Dtype dtype = null, NDarray @out = null, /// /// The correlation coefficient matrix of the variables. /// - public static NDarray corrcoef(NDarray x, NDarray y = null, bool? rowvar = true) + public static NDarray corrcoef(this NDarray x, NDarray y = null, bool? rowvar = true) { //auto-generated code, do not change var __self__=self; @@ -2541,7 +2541,7 @@ public static NDarray corrcoef(NDarray x, NDarray y = null, bool? rowvar = true) /// /// Discrete cross-correlation of a and v. /// - public static NDarray correlate(NDarray v, NDarray a, string mode = "valid") + public static NDarray correlate(this NDarray v, NDarray a, string mode = "valid") { //auto-generated code, do not change var __self__=self; @@ -2630,7 +2630,7 @@ public static NDarray correlate(NDarray v, NDarray a, string mode = "valid") /// /// The covariance matrix of the variables. /// - public static NDarray cov(NDarray m, NDarray y = null, bool? rowvar = true, bool? bias = false, int? ddof = null, NDarray fweights = null, NDarray aweights = null) + public static NDarray cov(this NDarray m, NDarray y = null, bool? rowvar = true, bool? bias = false, int? ddof = null, NDarray fweights = null, NDarray aweights = null) { //auto-generated code, do not change var __self__=self; @@ -2725,7 +2725,7 @@ public static NDarray cov(NDarray m, NDarray y = null, bool? rowvar = true, bool /// bin_edges /// Return the bin edges (length(hist)+1). /// - public static (NDarray, NDarray) histogram(NDarray a, int? bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) + public static (NDarray, NDarray) histogram(this NDarray a, int? bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) { //auto-generated code, do not change var __self__=self; @@ -2819,7 +2819,7 @@ public static (NDarray, NDarray) histogram(NDarray a, int? bins = null, (float, /// bin_edges /// Return the bin edges (length(hist)+1). /// - public static (NDarray, NDarray) histogram(NDarray a, NDarray bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) + public static (NDarray, NDarray) histogram(this NDarray a, NDarray bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) { //auto-generated code, do not change var __self__=self; @@ -2913,7 +2913,7 @@ public static (NDarray, NDarray) histogram(NDarray a, NDarray bins = null, (floa /// bin_edges /// Return the bin edges (length(hist)+1). /// - public static (NDarray, NDarray) histogram(NDarray a, List bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) + public static (NDarray, NDarray) histogram(this NDarray a, List bins = null, (float, float)? range = null, bool? normed = null, NDarray weights = null, bool? density = null) { //auto-generated code, do not change var __self__=self; @@ -2997,7 +2997,7 @@ public static (NDarray, NDarray) histogram(NDarray a, List bins = null, /// yedges /// The bin edges along the second dimension. /// - public static (NDarray, NDarray, NDarray) histogram2d(NDarray x, NDarray y, int? bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) + public static (NDarray, NDarray, NDarray) histogram2d(this NDarray x, NDarray y, int? bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3082,7 +3082,7 @@ public static (NDarray, NDarray, NDarray) histogram2d(NDarray x, NDarray y, int? /// yedges /// The bin edges along the second dimension. /// - public static (NDarray, NDarray, NDarray) histogram2d(NDarray x, NDarray y, NDarray bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) + public static (NDarray, NDarray, NDarray) histogram2d(this NDarray x, NDarray y, NDarray bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3167,7 +3167,7 @@ public static (NDarray, NDarray, NDarray) histogram2d(NDarray x, NDarray y, NDar /// yedges /// The bin edges along the second dimension. /// - public static (NDarray, NDarray, NDarray) histogram2d(NDarray x, NDarray y, List bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) + public static (NDarray, NDarray, NDarray) histogram2d(this NDarray x, NDarray y, List bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3237,7 +3237,7 @@ public static (NDarray, NDarray, NDarray) histogram2d(NDarray x, NDarray y, List /// edges /// A list of D arrays describing the bin edges for each dimension. /// - public static (NDarray, NDarray) histogramdd(NDarray sample, int? bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) + public static (NDarray, NDarray) histogramdd(this NDarray sample, int? bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3306,7 +3306,7 @@ public static (NDarray, NDarray) histogramdd(NDarray sample, int? bins = null, ( /// edges /// A list of D arrays describing the bin edges for each dimension. /// - public static (NDarray, NDarray) histogramdd(NDarray sample, NDarray bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) + public static (NDarray, NDarray) histogramdd(this NDarray sample, NDarray bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3375,7 +3375,7 @@ public static (NDarray, NDarray) histogramdd(NDarray sample, NDarray bins = null /// edges /// A list of D arrays describing the bin edges for each dimension. /// - public static (NDarray, NDarray) histogramdd(NDarray sample, List bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) + public static (NDarray, NDarray) histogramdd(this NDarray sample, List bins = null, (float, float)? range = null, bool? density = null, bool? normed = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3423,7 +3423,7 @@ public static (NDarray, NDarray) histogramdd(NDarray sample, List bins = /// /// The length of out is equal to np.amax(x)+1. /// - public static NDarray bincount(NDarray x, NDarray weights = null, int? minlength = 0) + public static NDarray bincount(this NDarray x, NDarray weights = null, int? minlength = 0) { //auto-generated code, do not change var __self__=self; @@ -3508,7 +3508,7 @@ public static NDarray bincount(NDarray x, NDarray weights = null, int? minlength /// /// The edges to pass into histogram /// - public static NDarray histogram_bin_edges(NDarray a, int? bins = null, (float, float)? range = null, NDarray weights = null) + public static NDarray histogram_bin_edges(this NDarray a, int? bins = null, (float, float)? range = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3594,7 +3594,7 @@ public static NDarray histogram_bin_edges(NDarray a, int? bins = null, (f /// /// The edges to pass into histogram /// - public static NDarray histogram_bin_edges(NDarray a, NDarray bins = null, (float, float)? range = null, NDarray weights = null) + public static NDarray histogram_bin_edges(this NDarray a, NDarray bins = null, (float, float)? range = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3680,7 +3680,7 @@ public static NDarray histogram_bin_edges(NDarray a, NDarray bins = null, /// /// The edges to pass into histogram /// - public static NDarray histogram_bin_edges(NDarray a, List bins = null, (float, float)? range = null, NDarray weights = null) + public static NDarray histogram_bin_edges(this NDarray a, List bins = null, (float, float)? range = null, NDarray weights = null) { //auto-generated code, do not change var __self__=self; @@ -3744,7 +3744,7 @@ public static NDarray histogram_bin_edges(NDarray a, List bins = /// /// Output array of indices, of same shape as x. /// - public static NDarray digitize(NDarray x, NDarray bins, bool? right = false) + public static NDarray digitize(this NDarray x, NDarray bins, bool? right = false) { //auto-generated code, do not change var __self__=self; diff --git a/src/Numpy/np.string.gen.cs b/src/Numpy/np.string.gen.cs index 6628111..78e53d2 100644 --- a/src/Numpy/np.string.gen.cs +++ b/src/Numpy/np.string.gen.cs @@ -677,6 +677,43 @@ public static NDarray split(string[] a, string sep = null, int? maxsplit = null) } } + public static partial class core { + public static partial class defchararray { + /// + /// For each element in a, return a list of the words in the + /// string, using sep as the delimiter string.

+ /// + /// Calls str.split element-wise. + /// + /// + /// If sep is not specified or None, any whitespace string is a + /// separator. + /// + /// + /// If maxsplit is given, at most maxsplit splits are done. + /// + /// + /// Array of list objects + /// + public static NDarray split(string[] a, int? sep = null, int? maxsplit = null) + { + //auto-generated code, do not change + var core = self.GetAttr("core"); + var defchararray = core.GetAttr("defchararray"); + var __self__=defchararray; + var pyargs=ToTuple(new object[] + { + a, + }); + var kwargs=new PyDict(); + if (sep!=null) kwargs["sep"]=ToPython(sep); + if (maxsplit!=null) kwargs["maxsplit"]=ToPython(maxsplit); + dynamic py = __self__.InvokeMethod("split", pyargs, kwargs); + return ToCsharp(py); + } + } + } + public static partial class core { public static partial class defchararray { /// diff --git a/src/ReleaseBot/Program.cs b/src/ReleaseBot/Program.cs index 7184846..69a61f8 100644 --- a/src/ReleaseBot/Program.cs +++ b/src/ReleaseBot/Program.cs @@ -13,8 +13,10 @@ namespace ReleaseBot { class Program { - private const string V = "1.25"; // <--- numpy.net version! - private const string PythonNetVersion = "2.5.1"; + private const string V = "1.35"; // <--- numpy.net version! + private const string PythonNetVersion = "3.0.1"; + private const string PythonVersion = "3.11"; // relevant only for Numpy with included binaries + private const string NumpyVersion = "1.23.5"; private const string ProjectPath = "../../../Numpy"; private const string ProjectName = "Numpy.csproj"; @@ -22,7 +24,7 @@ class Program private const string ProjectPath2 = "../../../Numpy.Bare"; private const string ProjectName2 = "Numpy.Bare.csproj"; - private const string Description = "C# bindings for NumPy on {0} - a fundamental library for scientific computing, machine learning and AI. Does require Python {1} with NumPy 1.16 installed!"; + private const string Description = "C# bindings for NumPy on {0} - a fundamental library for scientific computing, machine learning and AI. Does require Python {1} with NumPy {2} installed!"; private const string Tags = "Data science, Machine Learning, ML, AI, Scientific Computing, NumPy, Linear Algebra, FFT, SVD, BLAS, Vector, Matrix, Python"; static void Main(string[] args) @@ -31,60 +33,61 @@ static void Main(string[] args) ProcessNumpy(); // ==> Numpy Bare - - // first delete old packages as to not upload them again - foreach (var nuget in Directory.GetFiles(Path.Combine(ProjectPath2, "bin", "Release"), "*.nupkg")) - { - File.Delete(nuget); - } - - var specs = new ReleaseSpec[] - { - // linux - new ReleaseSpec() { CPythonVersion = "2.7", Platform="Linux", }, - new ReleaseSpec() { CPythonVersion = "3.5", Platform="Linux", }, - new ReleaseSpec() { CPythonVersion = "3.6", Platform="Linux", }, - new ReleaseSpec() { CPythonVersion = "3.8", Platform="Linux", }, - new ReleaseSpec() { CPythonVersion = "3.7", Platform="Linux", }, - // mac - new ReleaseSpec() { CPythonVersion = "2.7", Platform="OSX", }, - new ReleaseSpec() { CPythonVersion = "3.5", Platform="OSX", }, - new ReleaseSpec() { CPythonVersion = "3.6", Platform="OSX", }, - new ReleaseSpec() { CPythonVersion = "3.8", Platform="OSX", }, - new ReleaseSpec() { CPythonVersion = "3.7", Platform="OSX", }, - // win - new ReleaseSpec() { CPythonVersion = "2.7", Platform="Win64", }, - new ReleaseSpec() { CPythonVersion = "3.5", Platform="Win64", }, - new ReleaseSpec() { CPythonVersion = "3.6", Platform="Win64", }, - new ReleaseSpec() { CPythonVersion = "3.8", Platform="Win64", }, - new ReleaseSpec() { CPythonVersion = "3.7", Platform="Win64", }, - }; - foreach (var spec in specs) - { - spec.Version = $"{spec.CPythonVersion}.{V}"; - spec.PythonNetVersion = $"{PythonNetVersion}"; - spec.Description = string.Format(Description, spec.Platform, spec.CPythonVersion); - spec.PackageTags = Tags; - spec.RelativeProjectPath = ProjectPath2; - spec.ProjectName = ProjectName2; - var py = spec.CPythonVersion.Replace(".", ""); - switch (spec.Platform) - { - case "Linux": - spec.PackageId = "Numpy.Bare.Mono"; - spec.PythonNet = $"pythonnet_netstandard_py{py}_linux"; - break; - case "OSX": - spec.PackageId = "Numpy.Bare.OSX"; - spec.PythonNet = $"pythonnet_netstandard_py{py}_osx"; - break; - case "Win64": - spec.PackageId = "Numpy.Bare"; - spec.PythonNet = $"pythonnet_netstandard_py{py}_win"; - break; - } - spec.Process(); - } + // TODO: release numpy bare for the new Pythonnet 3.0.0 + //// first delete old packages as to not upload them again + //foreach (var nuget in Directory.GetFiles(Path.Combine(ProjectPath2, "bin", "Release"), "*.nupkg")) + //{ + // File.Delete(nuget); + //} + + //var specs = new ReleaseSpec[] + //{ + // // linux + // new ReleaseSpec() { CPythonVersion = "2.7", Platform="Linux", }, + // new ReleaseSpec() { CPythonVersion = "3.5", Platform="Linux", }, + // new ReleaseSpec() { CPythonVersion = "3.6", Platform="Linux", }, + // new ReleaseSpec() { CPythonVersion = "3.8", Platform="Linux", }, + // new ReleaseSpec() { CPythonVersion = "3.7", Platform="Linux", }, + // // mac + // new ReleaseSpec() { CPythonVersion = "2.7", Platform="OSX", }, + // new ReleaseSpec() { CPythonVersion = "3.5", Platform="OSX", }, + // new ReleaseSpec() { CPythonVersion = "3.6", Platform="OSX", }, + // new ReleaseSpec() { CPythonVersion = "3.8", Platform="OSX", }, + // new ReleaseSpec() { CPythonVersion = "3.7", Platform="OSX", }, + // // win + // new ReleaseSpec() { CPythonVersion = "2.7", Platform="Win64", }, + // new ReleaseSpec() { CPythonVersion = "3.5", Platform="Win64", }, + // new ReleaseSpec() { CPythonVersion = "3.6", Platform="Win64", }, + // new ReleaseSpec() { CPythonVersion = "3.8", Platform="Win64", }, + // new ReleaseSpec() { CPythonVersion = "3.7", Platform="Win64", }, + //}; + //foreach (var spec in specs) + //{ + // spec.Version = $"{spec.CPythonVersion}.{V}"; + // spec.PythonNetVersion = $"{PythonNetVersion}"; + // spec.NumpyVersion = NumpyVersion; + // spec.Description = string.Format(Description, spec.Platform, spec.CPythonVersion, spec.NumpyVersion); + // spec.PackageTags = Tags; + // spec.RelativeProjectPath = ProjectPath2; + // spec.ProjectName = ProjectName2; + // var py = spec.CPythonVersion.Replace(".", ""); + // switch (spec.Platform) + // { + // case "Linux": + // spec.PackageId = "Numpy.Bare.Mono"; + // spec.PythonNet = $"pythonnet_netstandard_py{py}_linux"; + // break; + // case "OSX": + // spec.PackageId = "Numpy.Bare.OSX"; + // spec.PythonNet = $"pythonnet_netstandard_py{py}_osx"; + // break; + // case "Win64": + // spec.PackageId = "Numpy.Bare"; + // spec.PythonNet = $"pythonnet_netstandard_py{py}_win"; + // break; + // } + // spec.Process(); + //} var key = File.ReadAllText("../../nuget.key").Trim(); foreach (var nuget in Directory.GetFiles(Path.Combine(ProjectPath2, "bin", "Release"), "*.nupkg")) @@ -111,7 +114,7 @@ private static void ProcessNumpy() var spec = new ReleaseSpec() { - Version = $"3.7.{V}", + Version = $"{PythonVersion}.{V}", ProjectName = ProjectName, RelativeProjectPath = ProjectPath, PackageId = "Numpy", @@ -188,6 +191,9 @@ public class ReleaseSpec /// public bool UsePythonIncluded { get; set; } + // Numpy Version + public string NumpyVersion { get; set; } + public void Process() { if (!File.Exists(FullProjectPath)) diff --git a/test/Numpy.UnitTest/NumPy_array_creation.tests.cs b/test/Numpy.UnitTest/NumPy_array_creation.tests.cs index 8b14d29..c4d81a1 100644 --- a/test/Numpy.UnitTest/NumPy_array_creation.tests.cs +++ b/test/Numpy.UnitTest/NumPy_array_creation.tests.cs @@ -355,6 +355,43 @@ public void full_likeTest() #endif } + [TestMethod] + public void arrayLeakTest() + { + var arr = new double[10_000_000]; + using (var process = System.Diagnostics.Process.GetCurrentProcess()) + { + long memStart; + long getMemAfterGc() + { + GC.Collect(2, GCCollectionMode.Forced, true, true); + process.Refresh(); + return process.PrivateMemorySize64; + } + long getOutstandingMem() => getMemAfterGc() - memStart; + + var ones = np.ones(10_000_000); // python runtime warmup + ones.Dispose(); + + memStart = getMemAfterGc(); + + ones = np.ones(10_000_000); + Assert.IsTrue(getOutstandingMem() > 70_000_000); + ones.Dispose(); + Assert.IsTrue(getOutstandingMem() < 1_000_000); + + var array = np.array(arr); + Assert.IsTrue(getOutstandingMem() > 70_000_000); + array.Dispose(); + Assert.IsTrue(getOutstandingMem() < 1_000_000); + + array = np.array(arr, np.float32); + Assert.IsTrue(getOutstandingMem() > 30_000_000); + array.Dispose(); + Assert.IsTrue(getOutstandingMem() < 1_000_000); + } + } + [TestMethod] public void arrayTest() { diff --git a/test/Numpy.UnitTest/NumPy_array_manipulation.tests.cs b/test/Numpy.UnitTest/NumPy_array_manipulation.tests.cs index 8544c2d..4f144c2 100644 --- a/test/Numpy.UnitTest/NumPy_array_manipulation.tests.cs +++ b/test/Numpy.UnitTest/NumPy_array_manipulation.tests.cs @@ -1579,17 +1579,17 @@ public void deleteTest() // [ 9, 10, 11, 12]]) // - NDarray given= np.array(new[,]{{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}); + NDarray given = np.array(new[,] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } }); var arr = given; - var expected= + var expected = "array([[ 1, 2, 3, 4],\n" + " [ 5, 6, 7, 8],\n" + " [ 9, 10, 11, 12]])"; Assert.AreEqual(expected, given.repr); - given= np.delete(arr, 1, 0); - expected= - "array([[ 1, 2, 3, 4],\n" + - " [ 9, 10, 11, 12]])"; + given = np.delete(arr, 1, 0); + expected = + "array([[ 1, 2, 3, 4],\n" + + " [ 9, 10, 11, 12]])"; Assert.AreEqual(expected, given.repr); // >>> np.delete(arr, np.s_[::2], 1) @@ -1601,15 +1601,15 @@ public void deleteTest() // - given= np.delete(arr, new Slice("::2"), 1); - expected= - "array([[ 2, 4],\n" + - " [ 6, 8],\n" + - " [10, 12]])"; + given = np.delete(arr, new Slice("::2"), 1); + expected = + "array([[ 2, 4],\n" + + " [ 6, 8],\n" + + " [10, 12]])"; Assert.AreEqual(expected, given.repr); - given= np.delete(arr, new [] {1,3,5}, null); - expected= - "array([ 1, 3, 5, 7, 8, 9, 10, 11, 12])"; + given = np.delete(arr, new[] { 1, 3, 5 }, null); + expected = + "array([ 1, 3, 5, 7, 8, 9, 10, 11, 12])"; Assert.AreEqual(expected, given.repr); } @@ -1630,49 +1630,45 @@ public void insertTest() // [3, 5, 3]]) // -#if TODO - var given= a = np.array({{1, 1}, {2, 2}, {3, 3}}); - given= a; - var expected= + NDarray a = np.array(new[,] { { 1, 1 }, { 2, 2 }, { 3, 3 } }); + var given = a; + var expected = "array([[1, 1],\n" + " [2, 2],\n" + " [3, 3]])"; Assert.AreEqual(expected, given.repr); - given= np.insert(a, 1, 5); - expected= + given = np.insert(a, 1, 5); + expected = "array([1, 5, 1, 2, 2, 3, 3])"; Assert.AreEqual(expected, given.repr); - given= np.insert(a, 1, 5, axis=1); - expected= + given = np.insert(a, 1, 5, axis: 1); + expected = "array([[1, 5, 1],\n" + " [2, 5, 2],\n" + " [3, 5, 3]])"; Assert.AreEqual(expected, given.repr); -#endif + // Difference between sequence and scalars: // >>> np.insert(a, [1], [[1],[2],[3]], axis=1) // array([[1, 1, 1], // [2, 2, 2], // [3, 3, 3]]) + given = np.insert(a, np.array(1), np.array(new[,] { { 1 }, { 2 }, { 3 } }), axis: 1); + expected = + "array([[1, 1, 1],\n" + + " [2, 2, 2],\n" + + " [3, 3, 3]])"; + // >>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1), // ... np.insert(a, [1], [[1],[2],[3]], axis=1)) // True // - -#if TODO - given= np.insert(a, {1}, {{1},{2},{3}}, axis=1); - expected= - "array([[1, 1, 1],\n" + - " [2, 2, 2],\n" + - " [3, 3, 3]])"; Assert.AreEqual(expected, given.repr); - given= np.array_equal(np.insert(a, 1, {1, 2, 3}, axis=1),; - expected= - "... np.insert(a, [1], [[1],[2],[3]], axis=1))\n" + - "True"; - Assert.AreEqual(expected, given.repr); -#endif + var equal = np.array_equal(np.insert(a, 1, np.array(new[] { 1, 2, 3 }), axis: 1), + np.insert(a, np.array(1), np.array(new[,] { { 1 }, { 2 }, { 3 } }), axis: 1)); + Assert.AreEqual(true, equal); + // >>> b = a.flatten() // >>> b // array([1, 1, 2, 2, 3, 3]) @@ -1680,37 +1676,35 @@ public void insertTest() // array([1, 1, 5, 6, 2, 2, 3, 3]) // -#if TODO - given= b = a.flatten(); - given= b; - expected= - "array([1, 1, 2, 2, 3, 3])"; + var b = a.flatten(); + given = b; + expected = + "array([1, 1, 2, 2, 3, 3])"; Assert.AreEqual(expected, given.repr); - given= np.insert(b, {2, 2}, {5, 6}); - expected= - "array([1, 1, 5, 6, 2, 2, 3, 3])"; + given = np.insert(b, np.array(new[] { 2, 2 }), np.array(new[] { 5, 6 })); + expected = + "array([1, 1, 5, 6, 2, 2, 3, 3])"; Assert.AreEqual(expected, given.repr); -#endif + // >>> np.insert(b, slice(2, 4), [5, 6]) // array([1, 1, 5, 2, 6, 2, 3, 3]) // -#if TODO - given= np.insert(b, slice(2, 4), {5, 6}); - expected= - "array([1, 1, 5, 2, 6, 2, 3, 3])"; + given = np.insert(b, new Slice(2, 4), np.array(new[] { 5, 6 })); + expected = + "array([1, 1, 5, 2, 6, 2, 3, 3])"; Assert.AreEqual(expected, given.repr); -#endif // >>> np.insert(b, [2, 2], [7.13, False]) # type casting // array([1, 1, 7, 0, 2, 2, 3, 3]) // -#if TODO - given= np.insert(b, {2, 2}, {7.13, False}) # type casting; - expected= +#if NOT_SUPPORTED + given = np.insert(b, np.array(new[] { 2, 2 }), np.array(new object[] { 7.13, false })); // type casting + expected= "array([1, 1, 7, 0, 2, 2, 3, 3])"; Assert.AreEqual(expected, given.repr); #endif + // >>> x = np.arange(8).reshape(2, 4) // >>> idx = (1, 3) // >>> np.insert(x, idx, 999, axis=1) @@ -1718,15 +1712,14 @@ public void insertTest() // [ 4, 999, 5, 6, 999, 7]]) // -#if TODO - given= x = np.arange(8).reshape(2, 4); - given= idx = (1, 3); - given= np.insert(x, idx, 999, axis=1); - expected= - "array([[ 0, 999, 1, 2, 999, 3],\n" + - " [ 4, 999, 5, 6, 999, 7]])"; + + var x = np.arange(8).reshape(2, 4); + NDarray idx = np.array(1, 3); + given = np.insert(x, idx, np.array(999), axis: 1); + expected = + "array([[ 0, 999, 1, 2, 999, 3],\n" + + " [ 4, 999, 5, 6, 999, 7]])"; Assert.AreEqual(expected, given.repr); -#endif } diff --git a/test/Numpy.UnitTest/NumPy_linalg.tests.cs b/test/Numpy.UnitTest/NumPy_linalg.tests.cs index bedb379..6a652e9 100644 --- a/test/Numpy.UnitTest/NumPy_linalg.tests.cs +++ b/test/Numpy.UnitTest/NumPy_linalg.tests.cs @@ -18,42 +18,42 @@ namespace Numpy.UnitTest [TestClass] public class NumPy_linalgTest : BaseTestCase { - + [TestMethod] public void dotTest() { // >>> np.dot(3, 4) // 12 // - - #if TODO + +#if TODO var given= np.dot(3, 4); var expected= "12"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Neither argument is complex-conjugated: - + // >>> np.dot([2j, 3j], [2j, 3j]) // (-13+0j) // - - #if TODO + +#if TODO given= np.dot({2j, 3j}, {2j, 3j}); expected= "(-13+0j)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // For 2-D arrays it is the matrix product: - + // >>> a = [[1, 0], [0, 1]] // >>> b = [[4, 1], [2, 2]] // >>> np.dot(a, b) // array([[4, 1], // [2, 2]]) // - - #if TODO + +#if TODO given= a = [[1, 0], [0, 1]]; given= b = [[4, 1], [2, 2]]; given= np.dot(a, b); @@ -61,7 +61,7 @@ public void dotTest() "array([[4, 1],\n" + " [2, 2]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) // >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) // >>> np.dot(a, b)[2,3,2,1,2,2] @@ -69,8 +69,8 @@ public void dotTest() // >>> sum(a[2,3,2,:] * b[1,2,:,2]) // 499128 // - - #if TODO + +#if TODO given= a = np.arange(3*4*5*6).reshape((3,4,5,6)); given= b = np.arange(3*4*5*6){::-1}.reshape((5,4,6,3)); given= np.dot(a, b){2,3,2,1,2,2}; @@ -81,15 +81,15 @@ public void dotTest() expected= "499128"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void multi_dotTest() { // multi_dot allows you to write: - + // >>> from numpy.linalg import multi_dot // >>> # Prepare some data // >>> A = np.random.random(10000, 100) @@ -99,8 +99,8 @@ public void multi_dotTest() // >>> # the actual dot multiplication // >>> multi_dot([A, B, C, D]) // - - #if TODO + +#if TODO var given= from numpy.linalg import multi_dot; given= # Prepare some data; given= A = np.random.random(10000, 100); @@ -109,22 +109,22 @@ public void multi_dotTest() given= D = np.random.random(5, 333); given= # the actual dot multiplication; given= multi_dot([A, B, C, D]); - #endif +#endif // instead of: - + // >>> np.dot(np.dot(np.dot(A, B), C), D) // >>> # or // >>> A.dot(B).dot(C).dot(D) // - - #if TODO + +#if TODO given= np.dot(np.dot(np.dot(A, B), C), D); given= # or; given= A.dot(B).dot(C).dot(D); - #endif +#endif } - - + + [TestMethod] public void vdotTest() { @@ -135,8 +135,8 @@ public void vdotTest() // >>> np.vdot(b, a) // (70+8j) // - - #if TODO + +#if TODO var given= a = np.array({1+2j,3+4j}); given= b = np.array({5+6j,7+8j}); given= np.vdot(a, b); @@ -147,9 +147,9 @@ public void vdotTest() expected= "(70+8j)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Note that higher-dimensional arrays are flattened! - + // >>> a = np.array([[1, 4], [5, 6]]) // >>> b = np.array([[4, 1], [2, 2]]) // >>> np.vdot(a, b) @@ -159,8 +159,8 @@ public void vdotTest() // >>> 1*4 + 4*1 + 5*2 + 6*2 // 30 // - - #if TODO + +#if TODO given= a = np.array({{1, 4}, {5, 6}}); given= b = np.array({{4, 1}, {2, 2}}); given= np.vdot(a, b); @@ -175,39 +175,39 @@ public void vdotTest() expected= "30"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void innerTest() { // Ordinary inner product for vectors: - + // >>> a = np.array([1,2,3]) // >>> b = np.array([0,1,0]) // >>> np.inner(a, b) // 2 // - - #if TODO + +#if TODO var given= a = np.array({1,2,3}); given= b = np.array({0,1,0}); given= np.inner(a, b); var expected= "2"; Assert.AreEqual(expected, given.repr); - #endif +#endif // A multidimensional example: - + // >>> a = np.arange(24).reshape((2,3,4)) // >>> b = np.arange(4) // >>> np.inner(a, b) // array([[ 14, 38, 62], // [ 86, 110, 134]]) // - - #if TODO + +#if TODO given= a = np.arange(24).reshape((2,3,4)); given= b = np.arange(4); given= np.inner(a, b); @@ -215,29 +215,29 @@ public void innerTest() "array([[ 14, 38, 62],\n" + " [ 86, 110, 134]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // An example where b is a scalar: - + // >>> np.inner(np.eye(2), 7) // array([[ 7., 0.], // [ 0., 7.]]) // - - #if TODO + +#if TODO given= np.inner(np.eye(2), 7); expected= "array([[ 7., 0.],\n" + " [ 0., 7.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void outerTest() { // Make a (very coarse) grid for computing a Mandelbrot set: - + // >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5)) // >>> rl // array([[-2., -1., 0., 1., 2.], @@ -260,8 +260,8 @@ public void outerTest() // [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j], // [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]]) // - - #if TODO + +#if TODO var given= rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5)); given= rl; var expected= @@ -289,17 +289,17 @@ public void outerTest() " [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j],\n" + " [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // An example using a “vector” of letters: - + // >>> x = np.array(['a', 'b', 'c'], dtype=object) // >>> np.outer(x, [1, 2, 3]) // array([[a, aa, aaa], // [b, bb, bbb], // [c, cc, ccc]], dtype=object) // - - #if TODO + +#if TODO given= x = np.array({'a', 'b', 'c'}, dtype=object); given= np.outer(x, {1, 2, 3}); expected= @@ -307,15 +307,15 @@ public void outerTest() " [b, bb, bbb],\n" + " [c, cc, ccc]], dtype=object)"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void matmulTest() { // For 2-D arrays it is the matrix product: - + // >>> a = np.array([[1, 0], // ... [0, 1]]) // >>> b = np.array([[4, 1], @@ -324,8 +324,8 @@ public void matmulTest() // array([[4, 1], // [2, 2]]) // - - #if TODO + +#if TODO var given= a = np.array({{1, 0},; var expected= "... [0, 1]])"; @@ -339,9 +339,9 @@ public void matmulTest() "array([[4, 1],\n" + " [2, 2]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // For 2-D mixed with 1-D, the result is the usual. - + // >>> a = np.array([[1, 0], // ... [0, 1]] // >>> b = np.array([1, 2]) @@ -350,8 +350,8 @@ public void matmulTest() // >>> np.matmul(b, a) // array([1, 2]) // - - #if TODO + +#if TODO given= a = np.array({{1, 0},; expected= "... [0, 1]]"; @@ -365,9 +365,9 @@ public void matmulTest() expected= "array([1, 2])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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 @@ -377,8 +377,8 @@ public void matmulTest() // >>> sum(a[0, 1, :] * b[0 , :, 1]) // 98 // - - #if TODO + +#if TODO given= a = np.arange(2 * 2 * 4).reshape((2, 2, 4)); given= b = np.arange(2 * 2 * 4).reshape((2, 4, 2)); given= np.matmul(a,b).shape; @@ -393,44 +393,44 @@ public void matmulTest() expected= "98"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Vector, vector returns the scalar inner product, but neither argument // is complex-conjugated: - + // >>> np.matmul([2j, 3j], [2j, 3j]) // (-13+0j) // - - #if TODO + +#if TODO given= np.matmul({2j, 3j}, {2j, 3j}); expected= "(-13+0j)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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 ... // - - #if TODO + +#if TODO given= np.matmul({1,2}, 3); expected= "Traceback (most recent call last):\n" + "...\n" + "ValueError: matmul: Input operand 1 does not have enough dimensions ..."; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void tensordotTest() { // A “traditional” example: - + // >>> a = np.arange(60.).reshape(3,4,5) // >>> b = np.arange(24.).reshape(4,3,2) // >>> c = np.tensordot(a,b, axes=([1,0],[0,1])) @@ -456,8 +456,8 @@ public void tensordotTest() // [ True, True], // [ True, True]]) // - - #if TODO + +#if TODO var given= a = np.arange(60.).reshape(3,4,5); given= b = np.arange(24.).reshape(4,3,2); given= c = np.tensordot(a,b, axes=({1,0},{0,1})); @@ -490,9 +490,9 @@ public void tensordotTest() " [ True, True],\n" + " [ True, True]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // An extended example taking advantage of the overloading of + and *: - + // >>> a = np.array(range(1, 9)) // >>> a.shape = (2, 2, 2) // >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object) @@ -505,8 +505,8 @@ public void tensordotTest() // array([[a, b], // [c, d]], dtype=object) // - - #if TODO + +#if TODO given= a = np.array(range(1, 9)); given= a.shape = (2, 2, 2); given= A = np.array(('a', 'b', 'c', 'd'), dtype=object); @@ -520,25 +520,25 @@ public void tensordotTest() "array([[a, b],\n" + " [c, d]], dtype=object)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.tensordot(a, A) # third argument default is 2 for double-contraction // array([abbcccdddd, aaaaabbbbbbcccccccdddddddd], dtype=object) // - - #if TODO + +#if TODO given= np.tensordot(a, A) # third argument default is 2 for double-contraction; expected= "array([abbcccdddd, aaaaabbbbbbcccccccdddddddd], dtype=object)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.tensordot(a, A, 1) // array([[[acc, bdd], // [aaacccc, bbbdddd]], // [[aaaaacccccc, bbbbbdddddd], // [aaaaaaacccccccc, bbbbbbbdddddddd]]], dtype=object) // - - #if TODO + +#if TODO given= np.tensordot(a, A, 1); expected= "array([[[acc, bdd],\n" + @@ -546,29 +546,29 @@ public void tensordotTest() " [[aaaaacccccc, bbbbbdddddd],\n" + " [aaaaaaacccccccc, bbbbbbbdddddddd]]], dtype=object)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.) // array([[[[[a, b], // [c, d]], // ... // - - #if TODO + +#if TODO given= np.tensordot(a, A, 0) # tensor product (result too long to incl.); expected= "array([[[[[a, b],\n" + " [c, d]],\n" + " ..."; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.tensordot(a, A, (0, 1)) // array([[[abbbbb, cddddd], // [aabbbbbb, ccdddddd]], // [[aaabbbbbbb, cccddddddd], // [aaaabbbbbbbb, ccccdddddddd]]], dtype=object) // - - #if TODO + +#if TODO given= np.tensordot(a, A, (0, 1)); expected= "array([[[abbbbb, cddddd],\n" + @@ -576,15 +576,15 @@ public void tensordotTest() " [[aaabbbbbbb, cccddddddd],\n" + " [aaaabbbbbbbb, ccccdddddddd]]], dtype=object)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.tensordot(a, A, (2, 1)) // array([[[abb, cdd], // [aaabbbb, cccdddd]], // [[aaaaabbbbbb, cccccdddddd], // [aaaaaaabbbbbbbb, cccccccdddddddd]]], dtype=object) // - - #if TODO + +#if TODO given= np.tensordot(a, A, (2, 1)); expected= "array([[[abb, cdd],\n" + @@ -592,30 +592,30 @@ public void tensordotTest() " [[aaaaabbbbbb, cccccdddddd],\n" + " [aaaaaaabbbbbbbb, cccccccdddddddd]]], dtype=object)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.tensordot(a, A, ((0, 1), (0, 1))) // array([abbbcccccddddddd, aabbbbccccccdddddddd], dtype=object) // - - #if TODO + +#if TODO given= np.tensordot(a, A, ((0, 1), (0, 1))); expected= "array([abbbcccccddddddd, aabbbbccccccdddddddd], dtype=object)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.tensordot(a, A, ((2, 1), (1, 0))) // array([acccbbdddd, aaaaacccccccbbbbbbdddddddd], dtype=object) // - - #if TODO + +#if TODO given= np.tensordot(a, A, ((2, 1), (1, 0))); expected= "array([acccbbdddd, aaaaacccccccbbbbbbdddddddd], dtype=object)"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void einsumTest() { @@ -623,14 +623,12 @@ public void einsumTest() // >>> b = np.arange(5) // >>> c = np.arange(6).reshape(2,3) // - - #if TODO - var given= a = np.arange(25).reshape(5,5); - given= b = np.arange(5); - given= c = np.arange(6).reshape(2,3); - #endif + + var a = np.arange(25).reshape(5, 5); + var b = np.arange(5); + var c = np.arange(6).reshape(2, 3); // Trace of a matrix: - + // >>> np.einsum('ii', a) // 60 // >>> np.einsum(a, [0,0]) @@ -638,23 +636,24 @@ public void einsumTest() // >>> np.trace(a) // 60 // - - #if TODO - given= np.einsum('ii', a); - var expected= + + var given = np.einsum("ii", a); + var expected = "60"; +#if TODO Assert.AreEqual(expected, given.repr); - given= np.einsum(a, {0,0}); - expected= - "60"; + given = np.einsum(new[] { a, (NDarray)np.array(0, 0) }); + expected = + "60"; Assert.AreEqual(expected, given.repr); - given= np.trace(a); - expected= - "60"; +#endif + given = np.trace(a); + expected = + "60"; Assert.AreEqual(expected, given.repr); - #endif + // Extract the diagonal (requires explicit form): - + // >>> np.einsum('ii->i', a) // array([ 0, 6, 12, 18, 24]) // >>> np.einsum(a, [0,0], [0]) @@ -662,23 +661,23 @@ public void einsumTest() // >>> np.diag(a) // array([ 0, 6, 12, 18, 24]) // - - #if TODO - given= np.einsum('ii->i', a); - expected= - "array([ 0, 6, 12, 18, 24])"; + + given = np.einsum("ii->i", a); + expected = + "array([ 0, 6, 12, 18, 24])"; Assert.AreEqual(expected, given.repr); - given= np.einsum(a, {0,0}, {0}); +#if TODO + given= np.einsum(a, {0,0}, {0}); expected= "array([ 0, 6, 12, 18, 24])"; Assert.AreEqual(expected, given.repr); - given= np.diag(a); - expected= - "array([ 0, 6, 12, 18, 24])"; +#endif + given = np.diag(a); + expected = + "array([ 0, 6, 12, 18, 24])"; Assert.AreEqual(expected, given.repr); - #endif // Sum over an axis (requires explicit form): - + // >>> np.einsum('ij->i', a) // array([ 10, 35, 60, 85, 110]) // >>> np.einsum(a, [0,1], [0]) @@ -686,41 +685,42 @@ public void einsumTest() // >>> np.sum(a, axis=1) // array([ 10, 35, 60, 85, 110]) // - - #if TODO - given= np.einsum('ij->i', a); - expected= - "array([ 10, 35, 60, 85, 110])"; + + given = np.einsum("ij->i", a); + expected = + "array([ 10, 35, 60, 85, 110])"; Assert.AreEqual(expected, given.repr); +#if TODO given= np.einsum(a, {0,1}, {0}); expected= "array([ 10, 35, 60, 85, 110])"; Assert.AreEqual(expected, given.repr); - given= np.sum(a, axis=1); - expected= - "array([ 10, 35, 60, 85, 110])"; +#endif + + given = np.sum(a, axis: 1); + expected = + "array([ 10, 35, 60, 85, 110])"; Assert.AreEqual(expected, given.repr); - #endif // For higher dimensional arrays summing a single axis can be done with ellipsis: - + // >>> np.einsum('...j->...', a) // array([ 10, 35, 60, 85, 110]) // >>> np.einsum(a, [Ellipsis,1], [Ellipsis]) // array([ 10, 35, 60, 85, 110]) // - - #if TODO - given= np.einsum('...j->...', a); - expected= - "array([ 10, 35, 60, 85, 110])"; + + given = np.einsum("...j->...", a); + expected = + "array([ 10, 35, 60, 85, 110])"; Assert.AreEqual(expected, given.repr); +#if TODO given= np.einsum(a, {Ellipsis,1}, {Ellipsis}); expected= "array([ 10, 35, 60, 85, 110])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Compute a matrix transpose, or reorder any number of axes: - + // >>> np.einsum('ji', c) // array([[0, 3], // [1, 4], @@ -738,35 +738,36 @@ public void einsumTest() // [1, 4], // [2, 5]]) // - - #if TODO - given= np.einsum('ji', c); - expected= - "array([[0, 3],\n" + - " [1, 4],\n" + - " [2, 5]])"; + + given = np.einsum("ji", c); + expected = + "array([[0, 3],\n" + + " [1, 4],\n" + + " [2, 5]])"; Assert.AreEqual(expected, given.repr); - given= np.einsum('ij->ji', c); - expected= - "array([[0, 3],\n" + - " [1, 4],\n" + - " [2, 5]])"; + given = np.einsum("ij->ji", c); + expected = + "array([[0, 3],\n" + + " [1, 4],\n" + + " [2, 5]])"; Assert.AreEqual(expected, given.repr); - given= np.einsum(c, {1,0}); +#if TODO + given= np.einsum(c, {1,0}); expected= "array([[0, 3],\n" + " [1, 4],\n" + " [2, 5]])"; Assert.AreEqual(expected, given.repr); - given= np.transpose(c); - expected= - "array([[0, 3],\n" + - " [1, 4],\n" + - " [2, 5]])"; +#endif + given = np.transpose(c); + expected = + "array([[0, 3],\n" + + " [1, 4],\n" + + " [2, 5]])"; Assert.AreEqual(expected, given.repr); - #endif + // Vector inner products: - + // >>> np.einsum('i,i', b, b) // 30 // >>> np.einsum(b, [0], b, [0]) @@ -774,23 +775,24 @@ public void einsumTest() // >>> np.inner(b,b) // 30 // - - #if TODO - given= np.einsum('i,i', b, b); - expected= - "30"; + + given = np.einsum("i,i", b, b); + expected = + "30"; Assert.AreEqual(expected, given.repr); +#if TODO given= np.einsum(b, {0}, b, {0}); expected= "30"; Assert.AreEqual(expected, given.repr); - given= np.inner(b,b); - expected= - "30"; +#endif + given = np.inner(b, b); + expected = + "30"; Assert.AreEqual(expected, given.repr); - #endif + // Matrix vector multiplication: - + // >>> np.einsum('ij,j', a, b) // array([ 30, 80, 130, 180, 230]) // >>> np.einsum(a, [0,1], b, [1]) @@ -800,27 +802,28 @@ public void einsumTest() // >>> np.einsum('...j,j', a, b) // array([ 30, 80, 130, 180, 230]) // - - #if TODO - given= np.einsum('ij,j', a, b); - expected= - "array([ 30, 80, 130, 180, 230])"; + + given = np.einsum("ij,j", a, b); + expected = + "array([ 30, 80, 130, 180, 230])"; Assert.AreEqual(expected, given.repr); +#if TODO given= np.einsum(a, {0,1}, b, {1}); expected= "array([ 30, 80, 130, 180, 230])"; Assert.AreEqual(expected, given.repr); - given= np.dot(a, b); - expected= - "array([ 30, 80, 130, 180, 230])"; +#endif + given = np.dot(a, b); + expected = + "array([ 30, 80, 130, 180, 230])"; Assert.AreEqual(expected, given.repr); - given= np.einsum('...j,j', a, b); - expected= - "array([ 30, 80, 130, 180, 230])"; + given = np.einsum("...j,j", a, b); + expected = + "array([ 30, 80, 130, 180, 230])"; Assert.AreEqual(expected, given.repr); - #endif + // Broadcasting and scalar multiplication: - + // >>> np.einsum('..., ...', 3, c) // array([[ 0, 3, 6], // [ 9, 12, 15]]) @@ -834,31 +837,31 @@ public void einsumTest() // array([[ 0, 3, 6], // [ 9, 12, 15]]) // - - #if TODO - given= np.einsum('..., ...', 3, c); - expected= - "array([[ 0, 3, 6],\n" + - " [ 9, 12, 15]])"; + + given = np.einsum("..., ...", np.asarray(3), c); + expected = + "array([[ 0, 3, 6],\n" + + " [ 9, 12, 15]])"; Assert.AreEqual(expected, given.repr); - given= np.einsum(',ij', 3, c); - expected= - "array([[ 0, 3, 6],\n" + - " [ 9, 12, 15]])"; + given = np.einsum(",ij", np.asarray(3), c); + expected = + "array([[ 0, 3, 6],\n" + + " [ 9, 12, 15]])"; Assert.AreEqual(expected, given.repr); +#if TODO given= np.einsum(3, {Ellipsis}, c, {Ellipsis}); expected= "array([[ 0, 3, 6],\n" + " [ 9, 12, 15]])"; Assert.AreEqual(expected, given.repr); - given= np.multiply(3, c); - expected= - "array([[ 0, 3, 6],\n" + - " [ 9, 12, 15]])"; +#endif + given = np.multiply(np.asarray(3), c); + expected = + "array([[ 0, 3, 6],\n" + + " [ 9, 12, 15]])"; Assert.AreEqual(expected, given.repr); - #endif // Vector outer product: - + // >>> np.einsum('i,j', np.arange(2)+1, b) // array([[0, 1, 2, 3, 4], // [0, 2, 4, 6, 8]]) @@ -869,26 +872,27 @@ public void einsumTest() // array([[0, 1, 2, 3, 4], // [0, 2, 4, 6, 8]]) // - - #if TODO - given= np.einsum('i,j', np.arange(2)+1, b); - expected= - "array([[0, 1, 2, 3, 4],\n" + - " [0, 2, 4, 6, 8]])"; + + + given = np.einsum("i,j", np.arange(2) + 1, b); + expected = + "array([[0, 1, 2, 3, 4],\n" + + " [0, 2, 4, 6, 8]])"; Assert.AreEqual(expected, given.repr); - given= np.einsum(np.arange(2)+1, {0}, b, {1}); +#if TODO + given= np.einsum(np.arange(2)+1, {0}, b, {1}); expected= "array([[0, 1, 2, 3, 4],\n" + " [0, 2, 4, 6, 8]])"; Assert.AreEqual(expected, given.repr); - given= np.outer(np.arange(2)+1, b); - expected= - "array([[0, 1, 2, 3, 4],\n" + - " [0, 2, 4, 6, 8]])"; +#endif + given = np.outer(np.arange(2) + 1, b); + expected = + "array([[0, 1, 2, 3, 4],\n" + + " [0, 2, 4, 6, 8]])"; Assert.AreEqual(expected, given.repr); - #endif // Tensor contraction: - + // >>> a = np.arange(60.).reshape(3,4,5) // >>> b = np.arange(24.).reshape(4,3,2) // >>> np.einsum('ijk,jil->kl', a, b) @@ -910,18 +914,18 @@ public void einsumTest() // [ 4796., 5162.], // [ 4928., 5306.]]) // - - #if TODO - given= a = np.arange(60.).reshape(3,4,5); - given= b = np.arange(24.).reshape(4,3,2); - given= np.einsum('ijk,jil->kl', a, b); - expected= - "array([[ 4400., 4730.],\n" + - " [ 4532., 4874.],\n" + - " [ 4664., 5018.],\n" + - " [ 4796., 5162.],\n" + - " [ 4928., 5306.]])"; - Assert.AreEqual(expected, given.repr); + + given = a = np.arange(60.0).reshape(3, 4, 5); + given = b = np.arange(24.0).reshape(4, 3, 2); + given = np.einsum("ijk,jil->kl", a, b); + expected = + "array([[4400., 4730.],\n" + + " [4532., 4874.],\n" + + " [4664., 5018.],\n" + + " [4796., 5162.],\n" + + " [4928., 5306.]])"; + Assert.AreEqual(expected, given.repr); +#if TODO given= np.einsum(a, {0,1,2}, b, {1,0,3}, {2,3}); expected= "array([[ 4400., 4730.],\n" + @@ -930,7 +934,8 @@ public void einsumTest() " [ 4796., 5162.],\n" + " [ 4928., 5306.]])"; Assert.AreEqual(expected, given.repr); - given= np.tensordot(a,b, axes=({1,0},{0,1})); + + given = np.tensordot(a,b, axes:new int[,]{{1,0},{0,1}}); expected= "array([[ 4400., 4730.],\n" + " [ 4532., 4874.],\n" + @@ -938,9 +943,10 @@ public void einsumTest() " [ 4796., 5162.],\n" + " [ 4928., 5306.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif + // Writeable returned arrays (since version 1.10.0): - + // >>> a = np.zeros((3, 3)) // >>> np.einsum('ii->i', a)[:] = 1 // >>> a @@ -948,19 +954,19 @@ public void einsumTest() // [ 0., 1., 0.], // [ 0., 0., 1.]]) // - - #if TODO - given= a = np.zeros((3, 3)); - given= np.einsum('ii->i', a){:} = 1; - given= a; - expected= - "array([[ 1., 0., 0.],\n" + - " [ 0., 1., 0.],\n" + - " [ 0., 0., 1.]])"; + + + a = np.zeros((3, 3)); + np.einsum("ii->i", a)[":"] = np.asarray(1); + given = a; + expected = + "array([[1., 0., 0.],\n" + + " [0., 1., 0.],\n" + + " [0., 0., 1.]])"; Assert.AreEqual(expected, given.repr); - #endif + // Example of ellipsis use: - + // >>> a = np.arange(6).reshape((3,2)) // >>> b = np.arange(12).reshape((4,3)) // >>> np.einsum('ki,jk->ij', a, b) @@ -973,32 +979,31 @@ public void einsumTest() // array([[10, 28, 46, 64], // [13, 40, 67, 94]]) // - - #if TODO - given= a = np.arange(6).reshape((3,2)); - given= b = np.arange(12).reshape((4,3)); - given= np.einsum('ki,jk->ij', a, b); - expected= - "array([[10, 28, 46, 64],\n" + - " [13, 40, 67, 94]])"; - Assert.AreEqual(expected, given.repr); - given= np.einsum('ki,...k->i...', a, b); - expected= - "array([[10, 28, 46, 64],\n" + - " [13, 40, 67, 94]])"; - Assert.AreEqual(expected, given.repr); - given= np.einsum('k...,jk', a, b); - expected= - "array([[10, 28, 46, 64],\n" + - " [13, 40, 67, 94]])"; + + given = a = np.arange(6).reshape((3, 2)); + given = b = np.arange(12).reshape((4, 3)); + given = np.einsum("ki,jk->ij", a, b); + expected = + "array([[10, 28, 46, 64],\n" + + " [13, 40, 67, 94]])"; + Assert.AreEqual(expected, given.repr); + given = np.einsum("ki,...k->i...", a, b); + expected = + "array([[10, 28, 46, 64],\n" + + " [13, 40, 67, 94]])"; + Assert.AreEqual(expected, given.repr); + given = np.einsum("k...,jk", a, b); + expected = + "array([[10, 28, 46, 64],\n" + + " [13, 40, 67, 94]])"; Assert.AreEqual(expected, given.repr); - #endif + // Chained array operations. For more complicated contractions, speed ups // might be achieved by repeatedly computing a ‘greedy’ path or pre-computing the // ‘optimal’ path and repeatedly applying it, using an // einsum_path insertion (since version 1.12.0). Performance improvements can be // particularly significant with larger arrays: - + // >>> a = np.ones(64).reshape(2,4,8) // # Basic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.) // >>> for iteration in range(500): @@ -1014,8 +1019,8 @@ public void einsumTest() // >>> for iteration in range(500): // ... np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path) // - - #if TODO + +#if TODO given= a = np.ones(64).reshape(2,4,8); // Basic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.) given= for iteration in range(500):; @@ -1038,10 +1043,10 @@ public void einsumTest() expected= "... np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void einsum_pathTest() { @@ -1050,7 +1055,7 @@ public void einsum_pathTest() // element of the path (1, 2). The resulting tensor is added to the end // of the contraction and the remaining contraction (0, 1) is then // completed. - + // >>> a = np.random.rand(2, 2) // >>> b = np.random.rand(2, 5) // >>> c = np.random.rand(5, 2) @@ -1071,8 +1076,8 @@ public void einsum_pathTest() // 3 kl,jk->jl ij,jl->il // 3 jl,ij->il il->il // - - #if TODO + +#if TODO var given= a = np.random.rand(2, 2); given= b = np.random.rand(2, 5); given= c = np.random.rand(5, 2); @@ -1096,23 +1101,23 @@ public void einsum_pathTest() " 3 kl,jk->jl ij,jl->il\n" + " 3 jl,ij->il il->il"; Assert.AreEqual(expected, given.repr); - #endif +#endif // A more complex index transformation example. - + // >>> I = np.random.rand(10, 10, 10, 10) // >>> C = np.random.rand(10, 10) // >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C, // optimize='greedy') // - - #if TODO + +#if TODO given= I = np.random.rand(10, 10, 10, 10); given= C = np.random.rand(10, 10); given= path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,; expected= " optimize='greedy')"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> print(path_info[0]) // ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)] // >>> print(path_info[1]) @@ -1131,8 +1136,8 @@ public void einsum_pathTest() // 5 cdef,gc->defg hd,defg->efgh // 5 defg,hd->efgh efgh->efgh // - - #if TODO + +#if TODO given= print(path_info[0]); expected= "['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]"; @@ -1154,10 +1159,10 @@ public void einsum_pathTest() " 5 cdef,gc->defg hd,defg->efgh\n" + " 5 defg,hd->efgh efgh->efgh"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void matrix_powerTest() { @@ -1173,8 +1178,8 @@ public void matrix_powerTest() // array([[ 0., 1.], // [-1., 0.]]) // - - #if TODO + +#if TODO var given= from numpy.linalg import matrix_power; given= i = np.array({{0, 1}, {-1, 0}}) # matrix equiv. of the imaginary unit; given= matrix_power(i, 3) # should = -i; @@ -1192,9 +1197,9 @@ public void matrix_powerTest() "array([[ 0., 1.],\n" + " [-1., 0.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Somewhat more sophisticated example - + // >>> q = np.zeros((4, 4)) // >>> q[0:2, 0:2] = -i // >>> q[2:4, 2:4] = i @@ -1209,8 +1214,8 @@ public void matrix_powerTest() // [ 0., 0., -1., 0.], // [ 0., 0., 0., -1.]]) // - - #if TODO + +#if TODO given= q = np.zeros((4, 4)); given= q[0:2, 0:2] = -i; given= q[2:4, 2:4] = i; @@ -1228,10 +1233,10 @@ public void matrix_powerTest() " [ 0., 0., -1., 0.],\n" + " [ 0., 0., 0., -1.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void kronTest() { @@ -1240,8 +1245,8 @@ public void kronTest() // >>> np.kron([5,6,7], [1,10,100]) // array([ 5, 50, 500, 6, 60, 600, 7, 70, 700]) // - - #if TODO + +#if TODO var given= np.kron({1,10,100}, {5,6,7}); var expected= "array([ 5, 6, 7, 50, 60, 70, 500, 600, 700])"; @@ -1250,15 +1255,15 @@ public void kronTest() expected= "array([ 5, 50, 500, 6, 60, 600, 7, 70, 700])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.kron(np.eye(2), np.ones((2,2))) // array([[ 1., 1., 0., 0.], // [ 1., 1., 0., 0.], // [ 0., 0., 1., 1.], // [ 0., 0., 1., 1.]]) // - - #if TODO + +#if TODO given= np.kron(np.eye(2), np.ones((2,2))); expected= "array([[ 1., 1., 0., 0.],\n" + @@ -1266,7 +1271,7 @@ public void kronTest() " [ 0., 0., 1., 1.],\n" + " [ 0., 0., 1., 1.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> a = np.arange(100).reshape((2,5,2,5)) // >>> b = np.arange(24).reshape((2,3,4)) // >>> c = np.kron(a,b) @@ -1280,8 +1285,8 @@ public void kronTest() // >>> c[K] == a[I]*b[J] // True // - - #if TODO + +#if TODO given= a = np.arange(100).reshape((2,5,2,5)); given= b = np.arange(24).reshape((2,3,4)); given= c = np.kron(a,b); @@ -1298,10 +1303,10 @@ public void kronTest() expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void qrTest() { @@ -1317,83 +1322,77 @@ public void qrTest() // >>> np.allclose(r, np.triu(r3[:6,:6], k=0)) // True // - - #if TODO - var given= a = np.random.randn(9, 6); - given= q, r = np.linalg.qr(a); - given= np.allclose(a, np.dot(q, r)) # a does equal qr; - var expected= - "True"; - Assert.AreEqual(expected, given.repr); - given= r2 = np.linalg.qr(a, mode='r'); - given= r3 = np.linalg.qr(a, mode='economic'); - given= np.allclose(r, r2) # mode='r' returns the same r as mode='full'; - expected= - "True"; - Assert.AreEqual(expected, given.repr); - given= # But only triu parts are guaranteed equal when mode='economic'; - given= np.allclose(r, np.triu(r3{:6,:6}, k=0)); + + { + var a = np.random.randn(9, 6); + var (q, r, _) = np.linalg.qr(a); + //Console.WriteLine("r: " + r.repr); + var given = np.allclose(a, np.dot(q, r)); // a does equal qr; + Assert.AreEqual(true, given); + (var r2, _, _) = np.linalg.qr(a, mode: "r"); + //Console.WriteLine("r2: " + r2.repr); + (var r3, _, _) = np.linalg.qr(a, mode: "economic"); + given = np.allclose(r, r2); // mode='r' returns the same r as mode='full'; + Assert.AreEqual(true, given); + } +#if TODO + // But only triu parts are guaranteed equal when mode='economic'; + given= np.allclose(r, np.triu(r3{:6,:6}, k=0)); expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif + // Example illustrating a common use of qr: solving of least squares // problems - + // What are the least-squares-best m and y0 in y = y0 + mx for // the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points // and you’ll see that it should be y0 = 0, m = 1.) The answer is provided // by solving the over-determined matrix equation Ax = b, where: - + // A = array([[0, 1], [1, 1], [1, 1], [2, 1]]) // x = array([[y0], [m]]) // b = array([[1], [0], [2], [1]]) // - - #if TODO - expected= - "A = array([[0, 1], [1, 1], [1, 1], [2, 1]])\n" + - "x = array([[y0], [m]])\n" + - "b = array([[1], [0], [2], [1]])"; - Assert.AreEqual(expected, given.repr); - #endif + // If A = qr such that q is orthonormal (which is always possible via // Gram-Schmidt), then x = inv(r) * (q.T) * b. (In numpy practice, // however, we simply use lstsq.) - - // >>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]]) - // >>> A - // array([[0, 1], - // [1, 1], - // [1, 1], - // [2, 1]]) - // >>> b = np.array([1, 0, 2, 1]) - // >>> q, r = LA.qr(A) - // >>> p = np.dot(q.T, b) - // >>> np.dot(LA.inv(r), p) - // array([ 1.1e-16, 1.0e+00]) + + //A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]]) + //A + //array([[0, 1], + // [1, 1], + // [1, 1], + // [2, 1]]) + //b = np.array([1, 2, 2, 3]) + //q, r = np.linalg.qr(A) + //p = np.dot(q.T, b) + //np.dot(np.linalg.inv(r), p) + //array([ 1., 1.]) // - - #if TODO - given= A = np.array({{0, 1}, {1, 1}, {1, 1}, {2, 1}}); - given= A; - expected= - "array([[0, 1],\n" + - " [1, 1],\n" + - " [1, 1],\n" + - " [2, 1]])"; - Assert.AreEqual(expected, given.repr); - given= b = np.array({1, 0, 2, 1}); - given= q, r = LA.qr(A); - given= p = np.dot(q.T, b); - given= np.dot(LA.inv(r), p); - expected= - "array([ 1.1e-16, 1.0e+00])"; - Assert.AreEqual(expected, given.repr); - #endif + { + var A = np.array(new[,] { { 0, 1 }, { 1, 1 }, { 1, 1 }, { 2, 1 } }); + NDarray given = A; + var expected = + "array([[0, 1],\n" + + " [1, 1],\n" + + " [1, 1],\n" + + " [2, 1]])"; + Assert.AreEqual(expected, given.repr); + var b = np.array(new[]{ 1, 2, 2, 3 }); + (var q, var r, _) = np.linalg.qr(A); + var p = np.dot(q.T, b); + //Console.WriteLine("p:" + p.repr); + var r_inv = np.linalg.inv(r); + given = np.dot(r_inv, p); + expected = "array([1., 1.])"; + Assert.AreEqual(expected, given.repr); + } } - - + + [TestMethod] public void condTest() { @@ -1422,8 +1421,8 @@ public void condTest() // >>> min(LA.svd(a, compute_uv=0))*min(LA.svd(LA.inv(a), compute_uv=0)) // 0.70710678118654746 // - - #if TODO + +#if TODO var given= from numpy import linalg as LA; given= a = np.array({{1, 0, -1}, {0, 1, 0}, {1, 0, 1}}); given= a; @@ -1468,10 +1467,10 @@ public void condTest() expected= "0.70710678118654746"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void matrix_rankTest() { @@ -1486,8 +1485,8 @@ public void matrix_rankTest() // >>> matrix_rank(np.zeros((4,))) // 0 // - - #if TODO + +#if TODO var given= from numpy.linalg import matrix_rank; given= matrix_rank(np.eye(4)) # Full rank matrix; var expected= @@ -1506,15 +1505,15 @@ public void matrix_rankTest() expected= "0"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void slogdetTest() { // The determinant of a 2-D array [[a, b], [c, d]] is ad - bc: - + // >>> a = np.array([[1, 2], [3, 4]]) // >>> (sign, logdet) = np.linalg.slogdet(a) // >>> (sign, logdet) @@ -1522,8 +1521,8 @@ public void slogdetTest() // >>> sign * np.exp(logdet) // -2.0 // - - #if TODO + +#if TODO var given= a = np.array({{1, 2}, {3, 4}}); given= (sign, logdet) = np.linalg.slogdet(a); given= (sign, logdet); @@ -1534,9 +1533,9 @@ public void slogdetTest() expected= "-2.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Computing log-determinants for a stack of matrices: - + // >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ]) // >>> a.shape // (3, 2, 2) @@ -1546,8 +1545,8 @@ public void slogdetTest() // >>> sign * np.exp(logdet) // array([-2., -3., -8.]) // - - #if TODO + +#if TODO given= a = np.array({ {{1, 2}, {3, 4}}, {{1, 2}, {2, 1}}, {{1, 3}, {3, 1}} }); given= a.shape; expected= @@ -1562,16 +1561,16 @@ public void slogdetTest() expected= "array([-2., -3., -8.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // This routine succeeds where ordinary det does not: - + // >>> np.linalg.det(np.eye(500) * 0.1) // 0.0 // >>> np.linalg.slogdet(np.eye(500) * 0.1) // (1, -1151.2925464970228) // - - #if TODO + +#if TODO given= np.linalg.det(np.eye(500) * 0.1); expected= "0.0"; @@ -1580,10 +1579,10 @@ public void slogdetTest() expected= "(1, -1151.2925464970228)"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void traceTest() { @@ -1593,8 +1592,8 @@ public void traceTest() // >>> np.trace(a) // array([6, 8]) // - - #if TODO + +#if TODO var given= np.trace(np.eye(3)); var expected= "3.0"; @@ -1604,22 +1603,22 @@ public void traceTest() expected= "array([6, 8])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> a = np.arange(24).reshape((2,2,2,3)) // >>> np.trace(a).shape // (2, 3) // - - #if TODO + +#if TODO given= a = np.arange(24).reshape((2,2,2,3)); given= np.trace(a).shape; expected= "(2, 3)"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void tensorsolveTest() { @@ -1632,8 +1631,8 @@ public void tensorsolveTest() // >>> np.allclose(np.tensordot(a, x, axes=3), b) // True // - - #if TODO + +#if TODO var given= a = np.eye(2*3*4); given= a.shape = (2*3, 4, 2, 3, 4); given= b = np.random.randn(2*3, 4); @@ -1646,10 +1645,10 @@ public void tensorsolveTest() expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void tensorinvTest() { @@ -1662,8 +1661,8 @@ public void tensorinvTest() // >>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b)) // True // - - #if TODO + +#if TODO var given= a = np.eye(4*6); given= a.shape = (4, 6, 8, 3); given= ainv = np.linalg.tensorinv(a, ind=2); @@ -1676,7 +1675,7 @@ public void tensorinvTest() expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> a = np.eye(4*6) // >>> a.shape = (24, 8, 3) // >>> ainv = np.linalg.tensorinv(a, ind=1) @@ -1686,8 +1685,8 @@ public void tensorinvTest() // >>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b)) // True // - - #if TODO + +#if TODO given= a = np.eye(4*6); given= a.shape = (24, 8, 3); given= ainv = np.linalg.tensorinv(a, ind=1); @@ -1700,10 +1699,10 @@ public void tensorinvTest() expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void LinAlgErrorTest() { @@ -1718,8 +1717,8 @@ public void LinAlgErrorTest() // raise LinAlgError('Singular matrix') // numpy.linalg.LinAlgError: Singular matrix // - - #if TODO + +#if TODO var given= from numpy import linalg as LA; given= LA.inv(np.zeros((2,2))); var expected= @@ -1732,8 +1731,8 @@ public void LinAlgErrorTest() " raise LinAlgError('Singular matrix')\n" + "numpy.linalg.LinAlgError: Singular matrix"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - + } } diff --git a/test/Numpy.UnitTest/NumPy_math.tests.cs b/test/Numpy.UnitTest/NumPy_math.tests.cs index 44035ac..4dfad8b 100644 --- a/test/Numpy.UnitTest/NumPy_math.tests.cs +++ b/test/Numpy.UnitTest/NumPy_math.tests.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using System.IO; using System.Linq; +using System.Numerics; using System.Runtime.InteropServices; using System.Text; using Numpy.Models; @@ -18,36 +19,36 @@ namespace Numpy.UnitTest [TestClass] public class NumPy_mathTest : BaseTestCase { - + [TestMethod] public void sinTest() { // Print sine of one angle: - + // >>> np.sin(np.pi/2.) // 1.0 // - - #if TODO + +#if TODO var given= np.sin(np.pi/2.); var expected= "1.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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. ]) // - - #if TODO + +#if TODO given= np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ); expected= "array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Plot the sine function: - + // >>> import matplotlib.pylab as plt // >>> x = np.linspace(-np.pi, np.pi, 201) // >>> plt.plot(x, np.sin(x)) @@ -56,8 +57,8 @@ public void sinTest() // >>> plt.axis('tight') // >>> plt.show() // - - #if TODO + +#if TODO given= import matplotlib.pylab as plt; given= x = np.linspace(-np.pi, np.pi, 201); given= plt.plot(x, np.sin(x)); @@ -65,10 +66,10 @@ public void sinTest() given= plt.ylabel('sin(x)'); given= plt.axis('tight'); given= plt.show(); - #endif +#endif } - - + + [TestMethod] public void cosTest() { @@ -86,8 +87,8 @@ public void cosTest() // File "", line 1, in // ValueError: invalid return array shape // - - #if TODO + +#if TODO var given= np.cos(np.array({0, np.pi/2, np.pi})); var expected= "array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00])"; @@ -107,10 +108,10 @@ public void cosTest() " File "", line 1, in \n" + "ValueError: invalid return array shape"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void tanTest() { @@ -130,8 +131,8 @@ public void tanTest() // File "", line 1, in // ValueError: invalid return array shape // - - #if TODO + +#if TODO var given= from math import pi; given= np.tan(np.array({-pi,pi/2,pi})); var expected= @@ -153,10 +154,10 @@ public void tanTest() " File "", line 1, in \n" + "ValueError: invalid return array shape"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void arcsinTest() { @@ -167,8 +168,8 @@ public void arcsinTest() // >>> np.arcsin(0) // 0.0 // - - #if TODO + +#if TODO var given= np.arcsin(1) # pi/2; var expected= "1.5707963267948966"; @@ -181,88 +182,88 @@ public void arcsinTest() expected= "0.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void arccosTest() { // We expect the arccos of 1 to be 0, and of -1 to be pi: - + // >>> np.arccos([1, -1]) // array([ 0. , 3.14159265]) // - - #if TODO + +#if TODO var given= np.arccos({1, -1}); var expected= "array([ 0. , 3.14159265])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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() // - - #if TODO + +#if TODO given= import matplotlib.pyplot as plt; given= x = np.linspace(-1, 1, num=100); given= plt.plot(x, np.arccos(x)); given= plt.axis('tight'); given= plt.show(); - #endif +#endif } - - + + [TestMethod] public void arctanTest() { // We expect the arctan of 0 to be 0, and of 1 to be pi/4: - + // >>> np.arctan([0, 1]) // array([ 0. , 0.78539816]) // - - #if TODO + +#if TODO var given= np.arctan({0, 1}); var expected= "array([ 0. , 0.78539816])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.pi/4 // 0.78539816339744828 // - - #if TODO + +#if TODO given= np.pi/4; expected= "0.78539816339744828"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Plot arctan: - + // >>> import matplotlib.pyplot as plt // >>> x = np.linspace(-10, 10) // >>> plt.plot(x, np.arctan(x)) // >>> plt.axis('tight') // >>> plt.show() // - - #if TODO + +#if TODO given= import matplotlib.pyplot as plt; given= x = np.linspace(-10, 10); given= plt.plot(x, np.arctan(x)); given= plt.axis('tight'); given= plt.show(); - #endif +#endif } - - + + [TestMethod] public void hypotTest() { @@ -271,64 +272,64 @@ public void hypotTest() // [ 5., 5., 5.], // [ 5., 5., 5.]]) // - - #if TODO + +#if TODO var given= np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))); var expected= "array([[ 5., 5., 5.],\n" + " [ 5., 5., 5.],\n" + " [ 5., 5., 5.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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.]]) // - - #if TODO + +#if TODO given= np.hypot(3*np.ones((3, 3)), {4}); expected= "array([[ 5., 5., 5.],\n" + " [ 5., 5., 5.],\n" + " [ 5., 5., 5.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void arctan2Test() { // 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.]) // - - #if TODO + +#if TODO var given= x = np.array({-1, +1, +1, -1}); given= y = np.array({-1, -1, +1, +1}); given= np.arctan2(y, x) * 180 / np.pi; var expected= "array([-135., -45., 45., 135.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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]) // - - #if TODO + +#if TODO given= np.arctan2({1., -1.}, {0., 0.}); expected= "array([ 1.57079633, -1.57079633])"; @@ -337,59 +338,59 @@ public void arctan2Test() expected= "array([ 0. , 3.14159265, 0.78539816])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void degreesTest() { // 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.]) // - - #if TODO + +#if TODO var given= rad = np.arange(12.)*np.pi/6; given= np.degrees(rad); var expected= "array([ 0., 30., 60., 90., 120., 150., 180., 210., 240.,\n" + " 270., 300., 330.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> out = np.zeros((rad.shape)) // >>> r = degrees(rad, out) // >>> np.all(r == out) // True // - - #if TODO + +#if TODO given= out = np.zeros((rad.shape)); given= r = degrees(rad, out); given= np.all(r == out); expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void radiansTest() { // 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]) // - - #if TODO + +#if TODO var given= deg = np.arange(12.) * 30.; given= np.radians(deg); var expected= @@ -397,24 +398,24 @@ public void radiansTest() " 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898,\n" + " 5.23598776, 5.75958653])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> out = np.zeros((deg.shape)) // >>> ret = np.radians(deg, out) // >>> ret is out // True // - - #if TODO + +#if TODO given= out = np.zeros((deg.shape)); given= ret = np.radians(deg, out); given= ret is out; expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void unwrapTest() { @@ -425,8 +426,8 @@ public void unwrapTest() // >>> np.unwrap(phase) // array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) // - - #if TODO + +#if TODO var given= phase = np.linspace(0, np.pi, num=5); given= phase{3:} += np.pi; given= phase; @@ -437,42 +438,42 @@ public void unwrapTest() expected= "array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void deg2radTest() { // >>> np.deg2rad(180) // 3.1415926535897931 // - - #if TODO + +#if TODO var given= np.deg2rad(180); var expected= "3.1415926535897931"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void rad2degTest() { // >>> np.rad2deg(np.pi/2) // 90.0 // - - #if TODO + +#if TODO var given= np.rad2deg(np.pi/2); var expected= "90.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void sinhTest() { @@ -484,8 +485,8 @@ public void sinhTest() // 1.2246063538223773e-016j // >>> # Discrepancy due to vagaries of floating point arithmetic. // - - #if TODO + +#if TODO var given= np.sinh(0); var expected= "0.0"; @@ -499,29 +500,29 @@ public void sinhTest() "1.2246063538223773e-016j"; Assert.AreEqual(expected, given.repr); given= # Discrepancy due to vagaries of floating point arithmetic.; - #endif +#endif // >>> # Example of providing the optional output parameter // >>> out2 = np.sinh([0.1], out1) // >>> out2 is out1 // True // - - #if TODO + +#if TODO given= # Example of providing the optional output parameter; given= out2 = np.sinh({0.1}, out1); given= out2 is out1; expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> # 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: invalid return array shape // - - #if TODO + +#if TODO given= # Example of ValueError due to provision of shape mis-matched `out`; given= np.sinh(np.zeros((3,3)),np.zeros((2,2))); expected= @@ -529,61 +530,61 @@ public void sinhTest() " File "", line 1, in \n" + "ValueError: invalid return array shape"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void coshTest() { // >>> np.cosh(0) // 1.0 // - - #if TODO + +#if TODO var given= np.cosh(0); var expected= "1.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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() // - - #if TODO + +#if TODO given= import matplotlib.pyplot as plt; given= x = np.linspace(-4, 4, 1000); given= plt.plot(x, np.cosh(x)); given= plt.show(); - #endif +#endif } - - + + [TestMethod] public void tanhTest() { // >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) // array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) // - - #if TODO + +#if TODO var given= np.tanh((0, np.pi*1j, np.pi*1j/2)); var expected= "array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> # Example of providing the optional output parameter illustrating // >>> # that what is returned is a reference to said parameter // >>> out2 = np.tanh([0.1], out1) // >>> out2 is out1 // True // - - #if TODO + +#if TODO given= # Example of providing the optional output parameter illustrating; given= # that what is returned is a reference to said parameter; given= out2 = np.tanh({0.1}, out1); @@ -591,15 +592,15 @@ public void tanhTest() expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> # 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: invalid return array shape // - - #if TODO + +#if TODO given= # Example of ValueError due to provision of shape mis-matched `out`; given= np.tanh(np.zeros((3,3)),np.zeros((2,2))); expected= @@ -607,26 +608,26 @@ public void tanhTest() " File "", line 1, in \n" + "ValueError: invalid return array shape"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void arcsinhTest() { // >>> np.arcsinh(np.array([np.e, 10.0])) // array([ 1.72538256, 2.99822295]) // - - #if TODO + +#if TODO var given= np.arcsinh(np.array({np.e, 10.0})); var expected= "array([ 1.72538256, 2.99822295])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void arccoshTest() { @@ -635,8 +636,8 @@ public void arccoshTest() // >>> np.arccosh(1) // 0.0 // - - #if TODO + +#if TODO var given= np.arccosh({np.e, 10.0}); var expected= "array([ 1.65745445, 2.99322285])"; @@ -645,26 +646,26 @@ public void arccoshTest() expected= "0.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void arctanhTest() { // >>> np.arctanh([0, -0.5]) // array([ 0. , -0.54930614]) // - - #if TODO + +#if TODO var given= np.arctanh({0, -0.5}); var expected= "array([ 0. , -0.54930614])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void aroundTest() { @@ -679,8 +680,8 @@ public void aroundTest() // >>> np.around([1,2,3,11], decimals=-1) // array([ 0, 0, 0, 10]) // - - #if TODO + +#if TODO var given= np.around({0.37, 1.64}); var expected= "array([ 0., 2.])"; @@ -701,10 +702,10 @@ public void aroundTest() expected= "array([ 0, 0, 0, 10])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void rintTest() { @@ -712,17 +713,17 @@ public void rintTest() // >>> np.rint(a) // array([-2., -2., -0., 0., 2., 2., 2.]) // - - #if TODO + +#if TODO var given= a = np.array({-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0}); given= np.rint(a); var expected= "array([-2., -2., -0., 0., 2., 2., 2.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void fixTest() { @@ -733,8 +734,8 @@ public void fixTest() // >>> np.fix([2.1, 2.9, -2.1, -2.9]) // array([ 2., 2., -2., -2.]) // - - #if TODO + +#if TODO var given= np.fix(3.14); var expected= "3.0"; @@ -747,10 +748,10 @@ public void fixTest() expected= "array([ 2., 2., -2., -2.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void floorTest() { @@ -758,17 +759,17 @@ public void floorTest() // >>> np.floor(a) // array([-2., -2., -1., 0., 1., 1., 2.]) // - - #if TODO + +#if TODO var given= a = np.array({-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0}); given= np.floor(a); var expected= "array([-2., -2., -1., 0., 1., 1., 2.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void ceilTest() { @@ -776,17 +777,17 @@ public void ceilTest() // >>> np.ceil(a) // array([-1., -1., -0., 1., 2., 2., 2.]) // - - #if TODO + +#if TODO var given= a = np.array({-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0}); given= np.ceil(a); var expected= "array([-1., -1., -0., 1., 2., 2., 2.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void truncTest() { @@ -794,14 +795,14 @@ public void truncTest() // >>> np.trunc(a) // array([-1., -1., -0., 0., 1., 1., 2.]) // - - #if TODO + +#if TODO var given= a = np.array({-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0}); given= np.trunc(a); var expected= "array([-1., -1., -0., 0., 1., 1., 2.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } @@ -870,55 +871,55 @@ public void sumTest() // >>> np.sum([[0, 1], [0, 5]], axis=1) // array([1, 5]) // - - var given= np.sum(new[]{0.5, 1.5}); - var expected= + + var given = np.sum(new[] { 0.5, 1.5 }); + var expected = "2.0"; Assert.AreEqual(expected, given.repr); - given= np.sum(new[] { 0.5, 0.7, 0.2, 1.5}, dtype:np.int32); - expected= - "1"; + given = np.sum(new[] { 0.5, 0.7, 0.2, 1.5 }, dtype: np.int32); + expected = + "1"; Assert.AreEqual(expected, given.repr); - given= np.sum(new[,] { {0, 1}, {0, 5}}); - expected= - "6"; + given = np.sum(new[,] { { 0, 1 }, { 0, 5 } }); + expected = + "6"; Assert.AreEqual(expected, given.repr); - given= np.sum(new[,] { {0, 1}, {0, 5}}, axis:0); - expected= - "array([0, 6])"; + given = np.sum(new[,] { { 0, 1 }, { 0, 5 } }, axis: 0); + expected = + "array([0, 6])"; Assert.AreEqual(expected, given.repr); - given= np.sum(new[,] { {0, 1}, {0, 5}}, axis: 1); - expected= - "array([1, 5])"; + given = np.sum(new[,] { { 0, 1 }, { 0, 5 } }, axis: 1); + expected = + "array([1, 5])"; Assert.AreEqual(expected, given.repr); // If the accumulator is too small, overflow occurs: - + // >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8) // -128 // - - #if TODO + +#if TODO given= np.ones(128, dtype=np.int8).sum(dtype=np.int8); expected= "-128"; Assert.AreEqual(expected, given.repr); - #endif +#endif // You can also start the sum with a value other than zero: - + // >>> np.sum([10], initial=5) // 15 // - - #if TODO + +#if TODO given= np.sum({10}, initial=5); expected= "15"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void nanprodTest() { @@ -934,8 +935,8 @@ public void nanprodTest() // >>> np.nanprod(a, axis=0) // array([ 3., 2.]) // - - #if TODO + +#if TODO var given= np.nanprod(1); var expected= "1"; @@ -957,10 +958,10 @@ public void nanprodTest() expected= "array([ 3., 2.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void nansumTest() { @@ -982,8 +983,8 @@ public void nansumTest() // >>> np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present // nan // - - #if TODO + +#if TODO var given= np.nansum(1); var expected= "1"; @@ -1017,10 +1018,10 @@ public void nansumTest() expected= "nan"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void cumprodTest() { @@ -1032,8 +1033,8 @@ public void cumprodTest() // >>> np.cumprod(a, dtype=float) # specify type of output // array([ 1., 2., 6., 24., 120., 720.]) // - - #if TODO + +#if TODO var given= a = np.array({1,2,3}); given= np.cumprod(a) # intermediate results 1, 1*2; var expected= @@ -1045,38 +1046,38 @@ public void cumprodTest() expected= "array([ 1., 2., 6., 24., 120., 720.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // The cumulative product for each column (i.e., over the rows) of a: - + // >>> np.cumprod(a, axis=0) // array([[ 1, 2, 3], // [ 4, 10, 18]]) // - - #if TODO + +#if TODO given= np.cumprod(a, axis=0); expected= "array([[ 1, 2, 3],\n" + " [ 4, 10, 18]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // The cumulative product for each row (i.e. over the columns) of a: - + // >>> np.cumprod(a,axis=1) // array([[ 1, 2, 6], // [ 4, 20, 120]]) // - - #if TODO + +#if TODO given= np.cumprod(a,axis=1); expected= "array([[ 1, 2, 6],\n" + " [ 4, 20, 120]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void cumsumTest() { @@ -1089,8 +1090,8 @@ public void cumsumTest() // >>> np.cumsum(a, dtype=float) # specifies type of output value(s) // array([ 1., 3., 6., 10., 15., 21.]) // - - #if TODO + +#if TODO var given= a = np.array({{1,2,3}, {4,5,6}}); given= a; var expected= @@ -1105,7 +1106,7 @@ public void cumsumTest() expected= "array([ 1., 3., 6., 10., 15., 21.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns // array([[1, 2, 3], // [5, 7, 9]]) @@ -1113,8 +1114,8 @@ public void cumsumTest() // array([[ 1, 3, 6], // [ 4, 9, 15]]) // - - #if TODO + +#if TODO given= np.cumsum(a,axis=0) # sum over rows for each of the 3 columns; expected= "array([[1, 2, 3],\n" + @@ -1125,10 +1126,10 @@ public void cumsumTest() "array([[ 1, 3, 6],\n" + " [ 4, 9, 15]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void nancumprodTest() { @@ -1148,8 +1149,8 @@ public void nancumprodTest() // array([[ 1., 2.], // [ 3., 3.]]) // - - #if TODO + +#if TODO var given= np.nancumprod(1); var expected= "array([1])"; @@ -1177,10 +1178,10 @@ public void nancumprodTest() "array([[ 1., 2.],\n" + " [ 3., 3.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void nancumsumTest() { @@ -1200,8 +1201,8 @@ public void nancumsumTest() // array([[ 1., 3.], // [ 3., 3.]]) // - - #if TODO + +#if TODO var given= np.nancumsum(1); var expected= "array([1])"; @@ -1229,10 +1230,10 @@ public void nancumsumTest() "array([[ 1., 3.],\n" + " [ 3., 3.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void diffTest() { @@ -1242,8 +1243,8 @@ public void diffTest() // >>> np.diff(x, n=2) // array([ 1, 1, -10]) // - - #if TODO + +#if TODO var given= x = np.array({1, 2, 4, 7, 0}); given= np.diff(x); var expected= @@ -1253,7 +1254,7 @@ public void diffTest() expected= "array([ 1, 1, -10])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]]) // >>> np.diff(x) // array([[2, 3, 4], @@ -1261,8 +1262,8 @@ public void diffTest() // >>> np.diff(x, axis=0) // array([[-1, 2, 0, -2]]) // - - #if TODO + +#if TODO given= x = np.array({{1, 3, 6, 10}, {0, 5, 6, 8}}); given= np.diff(x); expected= @@ -1273,22 +1274,22 @@ public void diffTest() expected= "array([[-1, 2, 0, -2]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64) // >>> np.diff(x) // array([1, 1], dtype='timedelta64[D]') // - - #if TODO + +#if TODO given= x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64); given= np.diff(x); expected= "array([1, 1], dtype='timedelta64[D]')"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void ediff1dTest() { @@ -1296,41 +1297,41 @@ public void ediff1dTest() // >>> np.ediff1d(x) // array([ 1, 2, 3, -7]) // - - #if TODO + +#if TODO var given= x = np.array({1, 2, 4, 7, 0}); given= np.ediff1d(x); var expected= "array([ 1, 2, 3, -7])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99])) // array([-99, 1, 2, 3, -7, 88, 99]) // - - #if TODO + +#if TODO given= np.ediff1d(x, to_begin=-99, to_end=np.array({88, 99})); expected= "array([-99, 1, 2, 3, -7, 88, 99])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // The returned array is always 1D. - + // >>> y = [[1, 2, 4], [1, 6, 24]] // >>> np.ediff1d(y) // array([ 1, 2, -3, 5, 18]) // - - #if TODO + +#if TODO given= y = [[1, 2, 4], [1, 6, 24]]; given= np.ediff1d(y); expected= "array([ 1, 2, -3, 5, 18])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void gradientTest() { @@ -1340,8 +1341,8 @@ public void gradientTest() // >>> np.gradient(f, 2) // array([ 0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ]) // - - #if TODO + +#if TODO var given= f = np.array({1, 2, 4, 7, 11, 16}, dtype=float); given= np.gradient(f); var expected= @@ -1351,58 +1352,58 @@ public void gradientTest() expected= "array([ 0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Spacing can be also specified with an array that represents the coordinates // of the values F along the dimensions. // For instance a uniform spacing: - + // >>> x = np.arange(f.size) // >>> np.gradient(f, x) // array([ 1. , 1.5, 2.5, 3.5, 4.5, 5. ]) // - - #if TODO + +#if TODO given= x = np.arange(f.size); given= np.gradient(f, x); expected= "array([ 1. , 1.5, 2.5, 3.5, 4.5, 5. ])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Or a non uniform one: - + // >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float) // >>> np.gradient(f, x) // array([ 1. , 3. , 3.5, 6.7, 6.9, 2.5]) // - - #if TODO + +#if TODO given= x = np.array({0., 1., 1.5, 3.5, 4., 6.}, dtype=float); given= np.gradient(f, x); expected= "array([ 1. , 3. , 3.5, 6.7, 6.9, 2.5])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // For two dimensional arrays, the return will be two arrays ordered by // axis. In this example the first array stands for the gradient in // rows and the second one in columns direction: - + // >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float)) // [array([[ 2., 2., -1.], // [ 2., 2., -1.]]), array([[ 1. , 2.5, 4. ], // [ 1. , 1. , 1. ]])] // - - #if TODO + +#if TODO given= np.gradient(np.array({{1, 2, 6}, {3, 4, 5}}, dtype=float)); expected= "[array([[ 2., 2., -1.],\n" + " [ 2., 2., -1.]]), array([[ 1. , 2.5, 4. ],\n" + " [ 1. , 1. , 1. ]])]"; Assert.AreEqual(expected, given.repr); - #endif +#endif // In this example the spacing is also specified: // uniform for axis=0 and non uniform for axis=1 - + // >>> dx = 2. // >>> y = [1., 1.5, 3.5] // >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y) @@ -1410,8 +1411,8 @@ public void gradientTest() // [ 1. , 1. , -0.5]]), array([[ 2. , 2. , 2. ], // [ 2. , 1.7, 0.5]])] // - - #if TODO + +#if TODO given= dx = 2.; given= y = [1., 1.5, 3.5]; given= np.gradient(np.array({{1, 2, 6}, {3, 4, 5}}, dtype=float), dx, y); @@ -1420,9 +1421,9 @@ public void gradientTest() " [ 1. , 1. , -0.5]]), array([[ 2. , 2. , 2. ],\n" + " [ 2. , 1.7, 0.5]])]"; Assert.AreEqual(expected, given.repr); - #endif +#endif // It is possible to specify how boundaries are treated using edge_order - + // >>> x = np.array([0, 1, 2, 3, 4]) // >>> f = x**2 // >>> np.gradient(f, edge_order=1) @@ -1430,8 +1431,8 @@ public void gradientTest() // >>> np.gradient(f, edge_order=2) // array([-0., 2., 4., 6., 8.]) // - - #if TODO + +#if TODO given= x = np.array({0, 1, 2, 3, 4}); given= f = x**2; given= np.gradient(f, edge_order=1); @@ -1442,103 +1443,103 @@ public void gradientTest() expected= "array([-0., 2., 4., 6., 8.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // The axis keyword can be used to specify a subset of axes of which the // gradient is calculated - + // >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0) // array([[ 2., 2., -1.], // [ 2., 2., -1.]]) // - - #if TODO + +#if TODO given= np.gradient(np.array({{1, 2, 6}, {3, 4, 5}}, dtype=float), axis=0); expected= "array([[ 2., 2., -1.],\n" + " [ 2., 2., -1.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void crossTest() { // Vector cross-product. - + // >>> x = [1, 2, 3] // >>> y = [4, 5, 6] // >>> np.cross(x, y) // array([-3, 6, -3]) // - - #if TODO + +#if TODO var given= x = [1, 2, 3]; given= y = [4, 5, 6]; given= np.cross(x, y); var expected= "array([-3, 6, -3])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // One vector with dimension 2. - + // >>> x = [1, 2] // >>> y = [4, 5, 6] // >>> np.cross(x, y) // array([12, -6, -3]) // - - #if TODO + +#if TODO given= x = [1, 2]; given= y = [4, 5, 6]; given= np.cross(x, y); expected= "array([12, -6, -3])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Equivalently: - + // >>> x = [1, 2, 0] // >>> y = [4, 5, 6] // >>> np.cross(x, y) // array([12, -6, -3]) // - - #if TODO + +#if TODO given= x = [1, 2, 0]; given= y = [4, 5, 6]; given= np.cross(x, y); expected= "array([12, -6, -3])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Both vectors with dimension 2. - + // >>> x = [1,2] // >>> y = [4,5] // >>> np.cross(x, y) // -3 // - - #if TODO + +#if TODO given= x = [1,2]; given= y = [4,5]; given= np.cross(x, y); expected= "-3"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Multiple vector cross-products. Note that the direction of the cross // product vector is defined by the right-hand rule. - + // >>> x = np.array([[1,2,3], [4,5,6]]) // >>> y = np.array([[4,5,6], [1,2,3]]) // >>> np.cross(x, y) // array([[-3, 6, -3], // [ 3, -6, 3]]) // - - #if TODO + +#if TODO given= x = np.array({{1,2,3}, {4,5,6}}); given= y = np.array({{4,5,6}, {1,2,3}}); given= np.cross(x, y); @@ -1546,25 +1547,25 @@ public void crossTest() "array([[-3, 6, -3],\n" + " [ 3, -6, 3]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // The orientation of c can be changed using the axisc keyword. - + // >>> np.cross(x, y, axisc=0) // array([[-3, 3], // [ 6, -6], // [-3, 3]]) // - - #if TODO + +#if TODO given= np.cross(x, y, axisc=0); expected= "array([[-3, 3],\n" + " [ 6, -6],\n" + " [-3, 3]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Change the vector definition of x and y using axisa and axisb. - + // >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]]) // >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]]) // >>> np.cross(x, y) @@ -1576,8 +1577,8 @@ public void crossTest() // [-30, 60, -30], // [-36, 72, -36]]) // - - #if TODO + +#if TODO given= x = np.array({{1,2,3}, {4,5,6}, {7, 8, 9}}); given= y = np.array({{7, 8, 9}, {4,5,6}, {1,2,3}}); given= np.cross(x, y); @@ -1592,10 +1593,10 @@ public void crossTest() " [-30, 60, -30],\n" + " [-36, 72, -36]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void trapzTest() { @@ -1614,8 +1615,8 @@ public void trapzTest() // >>> np.trapz(a, axis=1) // array([ 2., 8.]) // - - #if TODO + +#if TODO var given= np.trapz({1,2,3}); var expected= "4.0"; @@ -1642,53 +1643,53 @@ public void trapzTest() expected= "array([ 2., 8.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void expTest() { // Plot the magnitude and phase of exp(x) in the complex plane: - + // >>> import matplotlib.pyplot as plt // - - #if TODO + +#if TODO var given= import matplotlib.pyplot as plt; - #endif +#endif // >>> 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) // - - #if TODO + +#if TODO given= x = np.linspace(-2*np.pi, 2*np.pi, 100); given= xx = x + 1j * x{:, np.newaxis} # a + ib over complex plane; given= out = np.exp(xx); - #endif +#endif // >>> 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)') // - - #if TODO + +#if TODO given= plt.subplot(121); given= plt.imshow(np.abs(out),; var expected= "... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray')"; Assert.AreEqual(expected, given.repr); given= plt.title('Magnitude of exp(x)'); - #endif +#endif // >>> 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() // - - #if TODO + +#if TODO given= plt.subplot(122); given= plt.imshow(np.angle(out),; expected= @@ -1696,24 +1697,24 @@ public void expTest() Assert.AreEqual(expected, given.repr); given= plt.title('Phase (angle) of exp(x)'); given= plt.show(); - #endif +#endif } - - + + [TestMethod] public void expm1Test() { // 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 // - - #if TODO + +#if TODO var given= np.expm1(1e-10); var expected= "1.00000000005e-10"; @@ -1722,58 +1723,58 @@ public void expm1Test() expected= "1.000000082740371e-10"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void exp2Test() { // >>> np.exp2([2, 3]) // array([ 4., 8.]) // - - #if TODO + +#if TODO var given= np.exp2({2, 3}); var expected= "array([ 4., 8.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void logTest() { // >>> np.log([1, np.e, np.e**2, 0]) // array([ 0., 1., 2., -Inf]) // - - #if TODO + +#if TODO var given= np.log({1, np.e, np.e**2, 0}); var expected= "array([ 0., 1., 2., -Inf])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void log10Test() { // >>> np.log10([1e-15, -3.]) // array([-15., NaN]) // - - #if TODO + +#if TODO var given= np.log10({1e-15, -3.}); var expected= "array([-15., NaN])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void log2Test() { @@ -1781,29 +1782,29 @@ public void log2Test() // >>> np.log2(x) // array([-Inf, 0., 1., 4.]) // - - #if TODO + +#if TODO var given= x = np.array({0, 1, 2, 2**4}); given= np.log2(x); var expected= "array([-Inf, 0., 1., 4.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> 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]) // - - #if TODO + +#if TODO given= xi = np.array({0+1.j, 1, 2+0.j, 4.j}); given= np.log2(xi); expected= "array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void log1pTest() { @@ -1812,8 +1813,8 @@ public void log1pTest() // >>> np.log(1 + 1e-99) // 0.0 // - - #if TODO + +#if TODO var given= np.log1p(1e-99); var expected= "1e-99"; @@ -1822,10 +1823,10 @@ public void log1pTest() expected= "0.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void logaddexpTest() { @@ -1837,8 +1838,8 @@ public void logaddexpTest() // >>> np.exp(prob12) // 3.5000000000000057e-50 // - - #if TODO + +#if TODO var given= prob1 = np.log(1e-50); given= prob2 = np.log(2.5e-50); given= prob12 = np.logaddexp(prob1, prob2); @@ -1850,10 +1851,10 @@ public void logaddexpTest() expected= "3.5000000000000057e-50"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void logaddexp2Test() { @@ -1865,8 +1866,8 @@ public void logaddexp2Test() // >>> 2**prob12 // 3.4999999999999914e-50 // - - #if TODO + +#if TODO var given= prob1 = np.log2(1e-50); given= prob2 = np.log2(2.5e-50); given= prob12 = np.logaddexp2(prob1, prob2); @@ -1878,10 +1879,10 @@ public void logaddexp2Test() expected= "3.4999999999999914e-50"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void sincTest() { @@ -1903,8 +1904,8 @@ public void sincTest() // -5.84680802e-02, -8.90384387e-02, -8.40918587e-02, // -4.92362781e-02, -3.89804309e-17]) // - - #if TODO + +#if TODO var given= import matplotlib.pyplot as plt; given= x = np.linspace(-4, 4, 41); given= np.sinc(x); @@ -1924,7 +1925,7 @@ public void sincTest() " -5.84680802e-02, -8.90384387e-02, -8.40918587e-02,\n" + " -4.92362781e-02, -3.89804309e-17])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> plt.plot(x, np.sinc(x)) // [] // >>> plt.title("Sinc Function") @@ -1935,8 +1936,8 @@ public void sincTest() // // >>> plt.show() // - - #if TODO + +#if TODO given= plt.plot(x, np.sinc(x)); expected= "[]"; @@ -1954,26 +1955,26 @@ public void sincTest() ""; Assert.AreEqual(expected, given.repr); given= plt.show(); - #endif +#endif // It works in 2-D as well: - + // >>> x = np.linspace(-4, 4, 401) // >>> xx = np.outer(x, x) // >>> plt.imshow(np.sinc(xx)) // // - - #if TODO + +#if TODO given= x = np.linspace(-4, 4, 401); given= xx = np.outer(x, x); given= plt.imshow(np.sinc(xx)); expected= ""; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void signbitTest() { @@ -1982,8 +1983,8 @@ public void signbitTest() // >>> np.signbit(np.array([1, -2.3, 2.1])) // array([False, True, False]) // - - #if TODO + +#if TODO var given= np.signbit(-1.2); var expected= "True"; @@ -1992,10 +1993,10 @@ public void signbitTest() expected= "array([False, True, False])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void copysignTest() { @@ -2006,8 +2007,8 @@ public void copysignTest() // >>> 1/np.copysign(0, -1) // -inf // - - #if TODO + +#if TODO var given= np.copysign(1.3, -1); var expected= "-1.3"; @@ -2020,14 +2021,14 @@ public void copysignTest() expected= "-inf"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.copysign([-1, 0, 1], -1.1) // array([-1., -0., -1.]) // >>> np.copysign([-1, 0, 1], np.arange(3)-1) // array([-1., 0., 1.]) // - - #if TODO + +#if TODO given= np.copysign({-1, 0, 1}, -1.1); expected= "array([-1., -0., -1.])"; @@ -2036,10 +2037,10 @@ public void copysignTest() expected= "array([-1., 0., 1.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void frexpTest() { @@ -2053,8 +2054,8 @@ public void frexpTest() // >>> y1 * 2**y2 // array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) // - - #if TODO + +#if TODO var given= x = np.arange(9); given= y1, y2 = np.frexp(x); given= y1; @@ -2070,38 +2071,38 @@ public void frexpTest() expected= "array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void ldexpTest() { // >>> np.ldexp(5, np.arange(4)) // array([ 5., 10., 20., 40.], dtype=float32) // - - #if TODO + +#if TODO var given= np.ldexp(5, np.arange(4)); var expected= "array([ 5., 10., 20., 40.], dtype=float32)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> x = np.arange(6) // >>> np.ldexp(*np.frexp(x)) // array([ 0., 1., 2., 3., 4., 5.]) // - - #if TODO + +#if TODO given= x = np.arange(6); given= np.ldexp(*np.frexp(x)); expected= "array([ 0., 1., 2., 3., 4., 5.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void nextafterTest() { @@ -2111,8 +2112,8 @@ public void nextafterTest() // >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] // array([ True, True]) // - - #if TODO + +#if TODO var given= eps = np.finfo(np.float64).eps; given= np.nextafter(1, 2) == eps + 1; var expected= @@ -2122,26 +2123,26 @@ public void nextafterTest() expected= "array([ True, True])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void spacingTest() { // >>> np.spacing(1) == np.finfo(np.float64).eps // True // - - #if TODO + +#if TODO var given= np.spacing(1) == np.finfo(np.float64).eps; var expected= "True"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void lcmTest() { @@ -2154,8 +2155,8 @@ public void lcmTest() // >>> np.lcm(np.arange(6), 20) // array([ 0, 20, 20, 60, 20, 20]) // - - #if TODO + +#if TODO var given= np.lcm(12, 20); var expected= "60"; @@ -2172,10 +2173,10 @@ public void lcmTest() expected= "array([ 0, 20, 20, 60, 20, 20])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void gcdTest() { @@ -2186,8 +2187,8 @@ public void gcdTest() // >>> np.gcd(np.arange(6), 20) // array([20, 1, 2, 1, 4, 5]) // - - #if TODO + +#if TODO var given= np.gcd(12, 20); var expected= "4"; @@ -2200,10 +2201,10 @@ public void gcdTest() expected= "array([20, 1, 2, 1, 4, 5])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void addTest() { @@ -2216,8 +2217,8 @@ public void addTest() // [ 3., 5., 7.], // [ 6., 8., 10.]]) // - - #if TODO + +#if TODO var given= np.add(1.0, 4.0); var expected= "5.0"; @@ -2230,10 +2231,10 @@ public void addTest() " [ 3., 5., 7.],\n" + " [ 6., 8., 10.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void reciprocalTest() { @@ -2242,8 +2243,8 @@ public void reciprocalTest() // >>> np.reciprocal([1, 2., 3.33]) // array([ 1. , 0.5 , 0.3003003]) // - - #if TODO + +#if TODO var given= np.reciprocal(2.); var expected= "0.5"; @@ -2252,39 +2253,39 @@ public void reciprocalTest() expected= "array([ 1. , 0.5 , 0.3003003])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void negativeTest() { // >>> np.negative([1.,-1.]) // array([-1., 1.]) // - - #if TODO + +#if TODO var given= np.negative({1.,-1.}); var expected= "array([-1., 1.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void multiplyTest() { // >>> np.multiply(2.0, 4.0) // 8.0 // - - #if TODO + +#if TODO var given= np.multiply(2.0, 4.0); var expected= "8.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> x1 = np.arange(9.0).reshape((3, 3)) // >>> x2 = np.arange(3.0) // >>> np.multiply(x1, x2) @@ -2292,8 +2293,8 @@ public void multiplyTest() // [ 0., 4., 10.], // [ 0., 7., 16.]]) // - - #if TODO + +#if TODO given= x1 = np.arange(9.0).reshape((3, 3)); given= x2 = np.arange(3.0); given= np.multiply(x1, x2); @@ -2302,10 +2303,10 @@ public void multiplyTest() " [ 0., 4., 10.],\n" + " [ 0., 7., 16.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void divideTest() { @@ -2313,21 +2314,21 @@ public void divideTest() // >>> np.true_divide(x, 4) // array([ 0. , 0.25, 0.5 , 0.75, 1. ]) // - - #if TODO + +#if TODO var given= x = np.arange(5); given= np.true_divide(x, 4); var expected= "array([ 0. , 0.25, 0.5 , 0.75, 1. ])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> x/4 // array([0, 0, 0, 0, 1]) // >>> x//4 // array([0, 0, 0, 0, 1]) // - - #if TODO + +#if TODO given= x/4; expected= "array([0, 0, 0, 0, 1])"; @@ -2336,15 +2337,15 @@ public void divideTest() expected= "array([0, 0, 0, 0, 1])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> from __future__ import division // >>> x/4 // array([ 0. , 0.25, 0.5 , 0.75, 1. ]) // >>> x//4 // array([0, 0, 0, 0, 1]) // - - #if TODO + +#if TODO given= from __future__ import division; given= x/4; expected= @@ -2354,23 +2355,23 @@ public void divideTest() expected= "array([0, 0, 0, 0, 1])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void powerTest() { // Cube each element in a list. - + // >>> x1 = range(6) // >>> x1 // [0, 1, 2, 3, 4, 5] // >>> np.power(x1, 3) // array([ 0, 1, 8, 27, 64, 125]) // - - #if TODO + +#if TODO var given= x1 = range(6); given= x1; var expected= @@ -2380,23 +2381,23 @@ public void powerTest() expected= "array([ 0, 1, 8, 27, 64, 125])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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.]) // - - #if TODO + +#if TODO given= x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]; given= np.power(x1, x2); expected= "array([ 0., 1., 8., 27., 16., 5.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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], @@ -2405,8 +2406,8 @@ public void powerTest() // array([[ 0, 1, 8, 27, 16, 5], // [ 0, 1, 8, 27, 16, 5]]) // - - #if TODO + +#if TODO given= x2 = np.array({{1, 2, 3, 3, 2, 1}, {1, 2, 3, 3, 2, 1}}); given= x2; expected= @@ -2418,23 +2419,23 @@ public void powerTest() "array([[ 0, 1, 8, 27, 16, 5],\n" + " [ 0, 1, 8, 27, 16, 5]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void subtractTest() { // >>> np.subtract(1.0, 4.0) // -3.0 // - - #if TODO + +#if TODO var given= np.subtract(1.0, 4.0); var expected= "-3.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> x1 = np.arange(9.0).reshape((3, 3)) // >>> x2 = np.arange(3.0) // >>> np.subtract(x1, x2) @@ -2442,8 +2443,8 @@ public void subtractTest() // [ 3., 3., 3.], // [ 6., 6., 6.]]) // - - #if TODO + +#if TODO given= x1 = np.arange(9.0).reshape((3, 3)); given= x2 = np.arange(3.0); given= np.subtract(x1, x2); @@ -2452,10 +2453,10 @@ public void subtractTest() " [ 3., 3., 3.],\n" + " [ 6., 6., 6.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void true_divideTest() { @@ -2463,21 +2464,21 @@ public void true_divideTest() // >>> np.true_divide(x, 4) // array([ 0. , 0.25, 0.5 , 0.75, 1. ]) // - - #if TODO + +#if TODO var given= x = np.arange(5); given= np.true_divide(x, 4); var expected= "array([ 0. , 0.25, 0.5 , 0.75, 1. ])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> x/4 // array([0, 0, 0, 0, 1]) // >>> x//4 // array([0, 0, 0, 0, 1]) // - - #if TODO + +#if TODO given= x/4; expected= "array([0, 0, 0, 0, 1])"; @@ -2486,15 +2487,15 @@ public void true_divideTest() expected= "array([0, 0, 0, 0, 1])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> from __future__ import division // >>> x/4 // array([ 0. , 0.25, 0.5 , 0.75, 1. ]) // >>> x//4 // array([0, 0, 0, 0, 1]) // - - #if TODO + +#if TODO given= from __future__ import division; given= x/4; expected= @@ -2504,10 +2505,10 @@ public void true_divideTest() expected= "array([0, 0, 0, 0, 1])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void floor_divideTest() { @@ -2516,8 +2517,8 @@ public void floor_divideTest() // >>> np.floor_divide([1., 2., 3., 4.], 2.5) // array([ 0., 0., 1., 1.]) // - - #if TODO + +#if TODO var given= np.floor_divide(7,3); var expected= "2"; @@ -2526,23 +2527,23 @@ public void floor_divideTest() expected= "array([ 0., 0., 1., 1.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void float_powerTest() { // 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.]) // - - #if TODO + +#if TODO var given= x1 = range(6); given= x1; var expected= @@ -2552,23 +2553,23 @@ public void float_powerTest() expected= "array([ 0., 1., 8., 27., 64., 125.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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.]) // - - #if TODO + +#if TODO given= x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]; given= np.float_power(x1, x2); expected= "array([ 0., 1., 8., 27., 16., 5.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // 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], @@ -2577,8 +2578,8 @@ public void float_powerTest() // array([[ 0., 1., 8., 27., 16., 5.], // [ 0., 1., 8., 27., 16., 5.]]) // - - #if TODO + +#if TODO given= x2 = np.array({{1, 2, 3, 3, 2, 1}, {1, 2, 3, 3, 2, 1}}); given= x2; expected= @@ -2590,10 +2591,10 @@ public void float_powerTest() "array([[ 0., 1., 8., 27., 16., 5.],\n" + " [ 0., 1., 8., 27., 16., 5.]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void fmodTest() { @@ -2602,8 +2603,8 @@ public void fmodTest() // >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) // array([1, 0, 1, 1, 0, 1]) // - - #if TODO + +#if TODO var given= np.fmod({-3, -2, -1, 1, 2, 3}, 2); var expected= "array([-1, 0, -1, 1, 0, 1])"; @@ -2612,7 +2613,7 @@ public void fmodTest() expected= "array([1, 0, 1, 1, 0, 1])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.fmod([5, 3], [2, 2.]) // array([ 1., 1.]) // >>> a = np.arange(-3, 3).reshape(3, 2) @@ -2625,8 +2626,8 @@ public void fmodTest() // [-1, 0], // [ 1, 0]]) // - - #if TODO + +#if TODO given= np.fmod({5, 3}, {2, 2.}); expected= "array([ 1., 1.])"; @@ -2644,10 +2645,10 @@ public void fmodTest() " [-1, 0],\n" + " [ 1, 0]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void modTest() { @@ -2656,8 +2657,8 @@ public void modTest() // >>> np.remainder(np.arange(7), 5) // array([0, 1, 2, 3, 4, 0, 1]) // - - #if TODO + +#if TODO var given= np.remainder({4, 7}, {2, 3}); var expected= "array([0, 1])"; @@ -2666,10 +2667,10 @@ public void modTest() expected= "array([0, 1, 2, 3, 4, 0, 1])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void modfTest() { @@ -2678,8 +2679,8 @@ public void modfTest() // >>> np.modf(-0.5) // (-0.5, -0) // - - #if TODO + +#if TODO var given= np.modf({0, 3.5}); var expected= "(array([ 0. , 0.5]), array([ 0., 3.]))"; @@ -2688,10 +2689,10 @@ public void modfTest() expected= "(-0.5, -0)"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void remainderTest() { @@ -2700,8 +2701,8 @@ public void remainderTest() // >>> np.remainder(np.arange(7), 5) // array([0, 1, 2, 3, 4, 0, 1]) // - - #if TODO + +#if TODO var given= np.remainder({4, 7}, {2, 3}); var expected= "array([0, 1])"; @@ -2710,26 +2711,26 @@ public void remainderTest() expected= "array([0, 1, 2, 3, 4, 0, 1])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void divmodTest() { // >>> np.divmod(np.arange(5), 3) // (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) // - - #if TODO + +#if TODO var given= np.divmod(np.arange(5), 3); var expected= "(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void angleTest() { @@ -2738,8 +2739,8 @@ public void angleTest() // >>> np.angle(1+1j, deg=True) # in degrees // 45.0 // - - #if TODO + +#if TODO var given= np.angle({1.0, 1.0j, 1+1j}) # in radians; var expected= "array([ 0. , 1.57079633, 0.78539816])"; @@ -2748,10 +2749,10 @@ public void angleTest() expected= "45.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void realTest() { @@ -2767,8 +2768,8 @@ public void realTest() // >>> np.real(1 + 1j) // 1.0 // - - #if TODO + +#if TODO var given= a = np.array({1+2j, 3+4j, 5+6j}); given= a.real; var expected= @@ -2788,10 +2789,10 @@ public void realTest() expected= "1.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void imagTest() { @@ -2804,8 +2805,8 @@ public void imagTest() // >>> np.imag(1 + 1j) // 1.0 // - - #if TODO + +#if TODO var given= a = np.array({1+2j, 3+4j, 5+6j}); given= a.imag; var expected= @@ -2820,86 +2821,86 @@ public void imagTest() expected= "1.0"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void conjTest() { // >>> np.conjugate(1+2j) // (1-2j) // - - #if TODO + +#if TODO var given= np.conjugate(1+2j); var expected= "(1-2j)"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> x = np.eye(2) + 1j * np.eye(2) // >>> np.conjugate(x) // array([[ 1.-1.j, 0.-0.j], // [ 0.-0.j, 1.-1.j]]) // - - #if TODO + +#if TODO given= x = np.eye(2) + 1j * np.eye(2); given= np.conjugate(x); expected= "array([[ 1.-1.j, 0.-0.j],\n" + " [ 0.-0.j, 1.-1.j]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void convolveTest() { // Note how the convolution operator flips the second array // before “sliding” the two across one another: - + // >>> np.convolve([1, 2, 3], [0, 1, 0.5]) // array([ 0. , 1. , 2.5, 4. , 1.5]) // - - #if TODO + +#if TODO var given= np.convolve({1, 2, 3}, {0, 1, 0.5}); var expected= "array([ 0. , 1. , 2.5, 4. , 1.5])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Only return the middle values of the convolution. // Contains boundary effects, where zeros are taken // into account: - + // >>> np.convolve([1,2,3],[0,1,0.5], 'same') // array([ 1. , 2.5, 4. ]) // - - #if TODO + +#if TODO given= np.convolve({1,2,3},{0,1,0.5}, 'same'); expected= "array([ 1. , 2.5, 4. ])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // The two arrays are of the same length, so there // is only one position where they completely overlap: - + // >>> np.convolve([1,2,3],[0,1,0.5], 'valid') // array([ 2.5]) // - - #if TODO + +#if TODO given= np.convolve({1,2,3},{0,1,0.5}, 'valid'); expected= "array([ 2.5])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void clipTest() { @@ -2916,8 +2917,8 @@ public void clipTest() // >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8) // array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8]) // - - #if TODO + +#if TODO var given= a = np.arange(10); given= np.clip(a, 1, 8); var expected= @@ -2940,78 +2941,78 @@ public void clipTest() expected= "array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void sqrtTest() { // >>> np.sqrt([1,4,9]) // array([ 1., 2., 3.]) // - - #if TODO + +#if TODO var given= np.sqrt({1,4,9}); var expected= "array([ 1., 2., 3.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.sqrt([4, -1, -3+4J]) // array([ 2.+0.j, 0.+1.j, 1.+2.j]) // - - #if TODO + +#if TODO given= np.sqrt({4, -1, -3+4J}); expected= "array([ 2.+0.j, 0.+1.j, 1.+2.j])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.sqrt([4, -1, numpy.inf]) // array([ 2., NaN, Inf]) // - - #if TODO + +#if TODO given= np.sqrt({4, -1, numpy.inf}); expected= "array([ 2., NaN, Inf])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void cbrtTest() { // >>> np.cbrt([1,8,27]) // array([ 1., 2., 3.]) // - - #if TODO + +#if TODO var given= np.cbrt({1,8,27}); var expected= "array([ 1., 2., 3.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void squareTest() { // >>> np.square([-1j, 1]) // array([-1.-0.j, 1.+0.j]) // - - #if TODO + +#if TODO var given= np.square({-1j, 1}); var expected= "array([-1.-0.j, 1.+0.j])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void absoluteTest() { @@ -3021,8 +3022,8 @@ public void absoluteTest() // >>> np.absolute(1.2 + 1j) // 1.5620499351813308 // - - #if TODO + +#if TODO var given= x = np.array({-1.2, 1.2}); given= np.absolute(x); var expected= @@ -3032,40 +3033,40 @@ public void absoluteTest() expected= "1.5620499351813308"; Assert.AreEqual(expected, given.repr); - #endif +#endif // Plot the function over [-10, 10]: - + // >>> import matplotlib.pyplot as plt // - - #if TODO + +#if TODO given= import matplotlib.pyplot as plt; - #endif +#endif // >>> x = np.linspace(start=-10, stop=10, num=101) // >>> plt.plot(x, np.absolute(x)) // >>> plt.show() // - - #if TODO + +#if TODO given= x = np.linspace(start=-10, stop=10, num=101); given= plt.plot(x, np.absolute(x)); given= plt.show(); - #endif +#endif // 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() // - - #if TODO + +#if TODO given= xx = x + 1j * x{:, np.newaxis}; given= plt.imshow(np.abs(xx), extent={-10, 10, -10, 10}, cmap='gray'); given= plt.show(); - #endif +#endif } - - + + [TestMethod] public void fabsTest() { @@ -3074,8 +3075,8 @@ public void fabsTest() // >>> np.fabs([-1.2, 1.2]) // array([ 1.2, 1.2]) // - - #if TODO + +#if TODO var given= np.fabs(-1); var expected= "1.0"; @@ -3084,10 +3085,10 @@ public void fabsTest() expected= "array([ 1.2, 1.2])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void signTest() { @@ -3098,8 +3099,8 @@ public void signTest() // >>> np.sign(5-2j) // (1+0j) // - - #if TODO + +#if TODO var given= np.sign({-5., 4.5}); var expected= "array([-1., 1.])"; @@ -3112,10 +3113,10 @@ public void signTest() expected= "(1+0j)"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void heavisideTest() { @@ -3124,8 +3125,8 @@ public void heavisideTest() // >>> np.heaviside([-1.5, 0, 2.0], 1) // array([ 0., 1., 1.]) // - - #if TODO + +#if TODO var given= np.heaviside({-1.5, 0, 2.0}, 0.5); var expected= "array([ 0. , 0.5, 1. ])"; @@ -3134,42 +3135,42 @@ public void heavisideTest() expected= "array([ 0., 1., 1.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void maximumTest() { // >>> np.maximum([2, 3, 4], [1, 5, 2]) // array([2, 5, 4]) // - - #if TODO + +#if TODO var given= np.maximum({2, 3, 4}, {1, 5, 2}); var expected= "array([2, 5, 4])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting // array([[ 1. , 2. ], // [ 0.5, 2. ]]) // - - #if TODO + +#if TODO given= np.maximum(np.eye(2), {0.5, 2}) # broadcasting; expected= "array([[ 1. , 2. ],\n" + " [ 0.5, 2. ]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) // array([ NaN, NaN, NaN]) // >>> np.maximum(np.Inf, 1) // inf // - - #if TODO + +#if TODO given= np.maximum({np.nan, 0, np.nan}, {0, np.nan, np.nan}); expected= "array([ NaN, NaN, NaN])"; @@ -3178,42 +3179,42 @@ public void maximumTest() expected= "inf"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void minimumTest() { // >>> np.minimum([2, 3, 4], [1, 5, 2]) // array([1, 3, 2]) // - - #if TODO + +#if TODO var given= np.minimum({2, 3, 4}, {1, 5, 2}); var expected= "array([1, 3, 2])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting // array([[ 0.5, 0. ], // [ 0. , 1. ]]) // - - #if TODO + +#if TODO given= np.minimum(np.eye(2), {0.5, 2}) # broadcasting; expected= "array([[ 0.5, 0. ],\n" + " [ 0. , 1. ]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) // array([ NaN, NaN, NaN]) // >>> np.minimum(-np.Inf, 1) // -inf // - - #if TODO + +#if TODO given= np.minimum({np.nan, 0, np.nan},{0, np.nan, np.nan}); expected= "array([ NaN, NaN, NaN])"; @@ -3222,86 +3223,86 @@ public void minimumTest() expected= "-inf"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void fmaxTest() { // >>> np.fmax([2, 3, 4], [1, 5, 2]) // array([ 2., 5., 4.]) // - - #if TODO + +#if TODO var given= np.fmax({2, 3, 4}, {1, 5, 2}); var expected= "array([ 2., 5., 4.])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.fmax(np.eye(2), [0.5, 2]) // array([[ 1. , 2. ], // [ 0.5, 2. ]]) // - - #if TODO + +#if TODO given= np.fmax(np.eye(2), {0.5, 2}); expected= "array([[ 1. , 2. ],\n" + " [ 0.5, 2. ]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) // array([ 0., 0., NaN]) // - - #if TODO + +#if TODO given= np.fmax({np.nan, 0, np.nan},{0, np.nan, np.nan}); expected= "array([ 0., 0., NaN])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void fminTest() { // >>> np.fmin([2, 3, 4], [1, 5, 2]) // array([1, 3, 2]) // - - #if TODO + +#if TODO var given= np.fmin({2, 3, 4}, {1, 5, 2}); var expected= "array([1, 3, 2])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.fmin(np.eye(2), [0.5, 2]) // array([[ 0.5, 0. ], // [ 0. , 1. ]]) // - - #if TODO + +#if TODO given= np.fmin(np.eye(2), {0.5, 2}); expected= "array([[ 0.5, 0. ],\n" + " [ 0. , 1. ]])"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) // array([ 0., 0., NaN]) // - - #if TODO + +#if TODO given= np.fmin({np.nan, 0, np.nan},{0, np.nan, np.nan}); expected= "array([ 0., 0., NaN])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void nan_to_numTest() { @@ -3321,8 +3322,8 @@ public void nan_to_numTest() // 0.00000000e+000 +0.00000000e+000j, // 0.00000000e+000 +1.79769313e+308j]) // - - #if TODO + +#if TODO var given= np.nan_to_num(np.inf); var expected= "1.7976931348623157e+308"; @@ -3348,30 +3349,30 @@ public void nan_to_numTest() " 0.00000000e+000 +0.00000000e+000j,\n" + " 0.00000000e+000 +1.79769313e+308j])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void real_if_closeTest() { // >>> np.finfo(float).eps // 2.2204460492503131e-16 // - - #if TODO + +#if TODO var given= np.finfo(float).eps; var expected= "2.2204460492503131e-16"; Assert.AreEqual(expected, given.repr); - #endif +#endif // >>> np.real_if_close([2.1 + 4e-14j], tol=1000) // array([ 2.1]) // >>> np.real_if_close([2.1 + 4e-13j], tol=1000) // array([ 2.1 +4.00000000e-13j]) // - - #if TODO + +#if TODO given= np.real_if_close({2.1 + 4e-14j}, tol=1000); expected= "array([ 2.1])"; @@ -3380,10 +3381,10 @@ public void real_if_closeTest() expected= "array([ 2.1 +4.00000000e-13j])"; Assert.AreEqual(expected, given.repr); - #endif +#endif } - - + + [TestMethod] public void interpTest() { @@ -3397,91 +3398,53 @@ public void interpTest() // >>> np.interp(3.14, xp, fp, right=UNDEF) // -99.0 // - - #if TODO - var given= xp = [1, 2, 3]; - given= fp = [3, 2, 0]; - given= np.interp(2.5, xp, fp); - var expected= - "1.0"; - Assert.AreEqual(expected, given.repr); - given= np.interp({0, 1, 1.5, 2.72, 3.14}, xp, fp); - expected= - "array([ 3. , 3. , 2.5 , 0.56, 0. ])"; - Assert.AreEqual(expected, given.repr); - given= UNDEF = -99.0; - given= np.interp(3.14, xp, fp, right=UNDEF); - expected= - "-99.0"; - Assert.AreEqual(expected, given.repr); - #endif - // Plot an interpolant to the sine function: - - // >>> x = np.linspace(0, 2*np.pi, 10) - // >>> y = np.sin(x) - // >>> xvals = np.linspace(0, 2*np.pi, 50) - // >>> yinterp = np.interp(xvals, x, y) - // >>> import matplotlib.pyplot as plt - // >>> plt.plot(x, y, 'o') - // [] - // >>> plt.plot(xvals, yinterp, '-x') - // [] - // >>> plt.show() - // - - #if TODO - given= x = np.linspace(0, 2*np.pi, 10); - given= y = np.sin(x); - given= xvals = np.linspace(0, 2*np.pi, 50); - given= yinterp = np.interp(xvals, x, y); - given= import matplotlib.pyplot as plt; - given= plt.plot(x, y, 'o'); - expected= - "[]"; - Assert.AreEqual(expected, given.repr); - given= plt.plot(xvals, yinterp, '-x'); - expected= - "[]"; + + var xp = new float[] { 1, 2, 3 }; + var fp = new float[] { 3, 2, 0 }; + Assert.AreEqual(1.0f, np.interp(2.5f, xp, fp)); + + var given = np.interp(new float[] { 0, 1, 1.5f, 2.72f, 3.14f }, xp, fp); + var expected = + "array([3. , 3. , 2.5 , 0.55999994, 0. ])"; Assert.AreEqual(expected, given.repr); - given= plt.show(); - #endif + + var UNDEF = -99.0f; + Assert.AreEqual(-99.0f, np.interp(3.14f, xp, fp, right: UNDEF)); + // Interpolation with periodic x-coordinates: - + // >>> x = [-180, -170, -185, 185, -10, -5, 0, 365] // >>> xp = [190, -190, 350, -350] // >>> fp = [5, 10, 3, 4] // >>> np.interp(x, xp, fp, period=360) // array([7.5, 5., 8.75, 6.25, 3., 3.25, 3.5, 3.75]) // - - #if TODO - given= x = [-180, -170, -185, 185, -10, -5, 0, 365]; - given= xp = [190, -190, 350, -350]; - given= fp = [5, 10, 3, 4]; - given= np.interp(x, xp, fp, period=360); - expected= - "array([7.5, 5., 8.75, 6.25, 3., 3.25, 3.5, 3.75])"; + + //var x = [-180, -170, -185, 185, -10, -5, 0, 365]; + var x = new float[] { -180, -170, -185, 185, -10, -5, 0, 365 }; + xp = new float[] { 190, -190, 350, -350 }; + fp = new float[] { 5, 10, 3, 4 }; + given = np.interp(x, xp, fp, period: 360); + expected = + "array([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75])"; Assert.AreEqual(expected, given.repr); - #endif + // Complex interpolation: - + // >>> x = [1.5, 4.0] // >>> xp = [2,3,5] // >>> fp = [1.0j, 0, 2+3j] // >>> np.interp(x, xp, fp) // array([ 0.+1.j , 1.+1.5j]) - // - - #if TODO - given= x = [1.5, 4.0]; - given= xp = [2,3,5]; - given= fp = [1.0j, 0, 2+3j]; - given= np.interp(x, xp, fp); - expected= - "array([ 0.+1.j , 1.+1.5j])"; + + x = new float[] { 1.5f, 4.0f }; + xp = new float[] { 2, 3, 5 }; + var fp2 = new [] { new Complex(0, 1), new Complex(0, 0), new Complex(2, 3) }; + given = np.interp(x, xp, fp2); + expected = + "array([0.+1.j , 1.+1.5j])"; Assert.AreEqual(expected, given.repr); - #endif } - + } } diff --git a/test/Numpy.UnitTest/NumPy_other.tests.cs b/test/Numpy.UnitTest/NumPy_other.tests.cs new file mode 100644 index 0000000..6ded422 --- /dev/null +++ b/test/Numpy.UnitTest/NumPy_other.tests.cs @@ -0,0 +1,44 @@ +// Copyright (c) 2020 by Meinrad Recheis (Member of SciSharp) +// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion + +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using Python.Runtime; +using Numpy.Models; +#if PYTHON_INCLUDED +using Python.Included; +#endif + +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Assert = NUnit.Framework.Assert; + +namespace Numpy.UnitTest +{ + [TestClass] + public class NumPy_otherTest : BaseTestCase + { + + [TestMethod] + public void rootsTest() + { + // >>> coeff = [3.2, 2, 1] + // >>> np.roots(coeff) + // array([-0.3125+0.46351241j, -0.3125-0.46351241j]) + // + + #if TODO + var given= coeff = [3.2, 2, 1]; + given= np.roots(coeff); + var expected= + "array([-0.3125+0.46351241j, -0.3125-0.46351241j])"; + Assert.AreEqual(expected, given.repr); + #endif + } + + } +} diff --git a/test/Numpy.UnitTest/Numpy.UnitTest.csproj b/test/Numpy.UnitTest/Numpy.UnitTest.csproj index 813d965..4b4c1f7 100644 --- a/test/Numpy.UnitTest/Numpy.UnitTest.csproj +++ b/test/Numpy.UnitTest/Numpy.UnitTest.csproj @@ -11,6 +11,7 @@ + diff --git a/test/Numpy.UnitTest/NumpyTest.cs b/test/Numpy.UnitTest/NumpyTest.cs index ca6b5e5..e65c58c 100644 --- a/test/Numpy.UnitTest/NumpyTest.cs +++ b/test/Numpy.UnitTest/NumpyTest.cs @@ -1,10 +1,12 @@ -using System; +using System; using System.Collections.Generic; using System.Drawing; +using System.Globalization; using System.IO; using System.Linq; using System.Numerics; using System.Runtime.InteropServices; +using System.Threading.Tasks; using Microsoft.VisualStudio.TestTools.UnitTesting; using Numpy; using Numpy.Models; @@ -16,6 +18,12 @@ namespace Numpy.UnitTest [TestClass] public class NumpyTest { + [AssemblyCleanup()] + public static void AssemblyCleanup() + { + PythonEngine.BeginAllowThreads(); + } + [TestMethod] public void empty() { @@ -32,8 +40,7 @@ public void empty() public unsafe void create_from_pointer_without_copying() { IntPtr pointer = IntPtr.Zero; - try - { + try { var dtype = np.int32; const int length = 1024; pointer = Marshal.AllocHGlobal(length); @@ -49,8 +56,7 @@ public unsafe void create_from_pointer_without_copying() var truth2 = a.Equals(b); Assert.AreEqual(b, a); } - finally - { + finally { if (pointer != IntPtr.Zero) Marshal.FreeHGlobal(pointer); } @@ -346,14 +352,14 @@ public void ndarray_masking1() " [[15, 16, 17, 18, 19],\n" + " [20, 21, 22, 23, 24],\n" + " [25, 26, 27, 28, 29]]])", - x.repr); + x.repr); var b = np.array(new[,] { { true, true, false }, { false, true, true } }); Assert.AreEqual( "array([[ 0, 1, 2, 3, 4],\n" + " [ 5, 6, 7, 8, 9],\n" + " [20, 21, 22, 23, 24],\n" + " [25, 26, 27, 28, 29]])", - x[b].repr); + x[b].repr); } [TestMethod] @@ -636,12 +642,11 @@ public void ComplexNumbers() public void IssueByXlient() { var points = new Point[] { new Point(0, 0), new Point(17, 4), new Point(2, 22), new Point(10, 7), }; - int[,] Pts = new int[,] - { - {points[0].X, points[0].Y }, - {points[1].X, points[1].Y }, - {points[2].X, points[2].Y } , - {points[3].X, points[3].Y } + int[,] Pts = new int[,] { + { points[0].X, points[0].Y }, + { points[1].X, points[1].Y }, + { points[2].X, points[2].Y }, + { points[3].X, points[3].Y } }; // exception here / deadlock @@ -669,7 +674,7 @@ public void IssueByVolgaone() Assert.AreEqual("1,2,3", string.Join(",", row0Data)); var col1 = n[":,1"]; //extract 1st column - NDarray is [2 5 8] as expected Assert.AreEqual("array([2., 5., 8.], dtype=float32)", col1.repr); - var col1Data = col1.GetData();//this is wrong - {2,3,4} + var col1Data = col1.GetData(); //this is wrong - {2,3,4} Assert.AreEqual("2,5,8", string.Join(",", col1Data)); } @@ -678,7 +683,7 @@ public void IssueByNbustins() { int[,,,] iarr = new int[3, 25, 25, 3]; NDarray nd = np.array(iarr); - Assert.AreEqual(new Shape(3,25,25,3), nd.shape); + Assert.AreEqual(new Shape(3, 25, 25, 3), nd.shape); } [TestMethod] @@ -694,12 +699,12 @@ public void IssueByBanyc1() //data['b'] //array([1, 2]) //data.close() - var a = np.array(new[,] {{1, 2, 3}, {4, 5, 6}}); - var b = np.array(new[] {1, 2}); + var a = np.array(new[,] { { 1, 2, 3 }, { 4, 5, 6 } }); + var b = np.array(new[] { 1, 2 }); string tempFile = Path.GetTempFileName() + ".npz"; Console.WriteLine(tempFile); - np.savez(tempFile, kwds:new Dictionary() {["a"]=a, ["b"]=b}); - var data = np.load(tempFile, allow_pickle:true); + np.savez(tempFile, kwds: new Dictionary() { ["a"] = a, ["b"] = b }); + var data = np.load(tempFile, allow_pickle: true); var a1 = new NDarray(data.self["a"]); Console.WriteLine(a1.repr); var b1 = new NDarray(data.self["b"]); @@ -715,7 +720,7 @@ public void IssueByBanyc2() var b = np.array(new[] { 1, 2 }); string tempFile = Path.GetTempFileName() + ".npz"; Console.WriteLine(tempFile); - np.savez(tempFile, new []{ a, b }); + np.savez(tempFile, new[] { a, b }); var data = np.load(tempFile, allow_pickle: true); var a1 = new NDarray(data.self["arr_0"]); Console.WriteLine(a1.repr); @@ -791,17 +796,354 @@ public void IssueBybeanels01() //# 2 //# 2 var result = new List(); - var nc = np.array(new[] {np.array(new[] {1, 2, 3}), np.array(new[] {4, 5, 6}), np.array(new[] {7, 8, 9})}); - for (int i = 0; i < nc.len; i++) - { + var nc = np.array(new[] { np.array(new[] { 1, 2, 3 }), np.array(new[] { 4, 5, 6 }), np.array(new[] { 7, 8, 9 }) }); + for (int i = 0; i < nc.len; i++) { + var n = np.argmax(nc[i]).asscalar(); + result.Add(n); + } + Assert.AreEqual("2, 2, 2", string.Join(", ", result)); + } + + [TestMethod] + public void IssueBybeanels01a() + { + //sample = [np.array([[1., 2., 3.]]),np.array([[4., 5., 6.]]),np.array([[7., 8., 9.]])] + //for test in sample: + // n = np.argmax(test[0]) + // print(n) + //# expected: + //# 2 + //# 2 + //# 2 + var result = new List(); + var nc = np.array(new[] { np.array(new[] { 1, 2, 3 }), np.array(new[] { 4, 5, 6 }), np.array(new[] { 7, 8, 9 }) }); + for (int i = 0; i < nc.len; i++) { var n = np.argmax(nc[i]).asscalar(); result.Add(n); } Assert.AreEqual("2, 2, 2", string.Join(", ", result)); } - // TODO: https://docs.scipy.org/doc/numpy/user/basics.indexing.html?highlight=slice#structural-indexing-tools + [TestMethod] + public void IssueByMatteo_0() + { + //>>> x = np.array([0, 1, 2, 3]) + //>>> y = np.array([-1, 0.2, 0.9, 2.1]) + //>>> A = np.vstack([x, np.ones(len(x))]).T + //>>> A + //array([[0., 1.], + // [1., 1.], + // [2., 1.], + // [3., 1.]]) + //>>> np.linalg.lstsq(A, y, rcond = None) + //(array([1. , -0.95]), array([0.05]), 2, array([4.10003045, 1.09075677])) + var x = np.array(new[] { 0, 1, 2, 3 }); + var y = np.array(new[] { -1, 0.2, 0.9, 2.1 }); + var A = np.vstack(x, np.ones(x.len)).T; + Assert.AreEqual("array([[0., 1.],\n [1., 1.],\n [2., 1.],\n [3., 1.]])", A.repr); + var tuple = np.linalg.lstsq(A, y, null); + Assert.AreEqual("array([ 1. , -0.95])", tuple.Item1.repr); + Assert.AreEqual("array([0.05])", tuple.Item2.repr); + Assert.AreEqual(2, tuple.Item3); + Assert.AreEqual("array([4.10003045, 1.09075677])", tuple.Item4.repr); + } + + [TestMethod] + public void IssueByDecemberDream() + { + //a = np.array([1, 2, -2, -4, 0]) + //np.roots(a) + //# returns array([ 1.41421356, -2., -1.41421356, 0.]) + var a = np.array(new[] { 1, 2, -2, -4, 0 }); + var b = np.roots(a); + Assert.AreEqual("array([ 1.41421356, -2. , -1.41421356, 0. ])", b.repr); + } + + [TestMethod] + public void IssueByDecemberDream2() + { + NDarray test = np.array(new int[,] { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 9, 10, 11 } }); + NDarray rows = np.array(new int[,] { { 0, 0 }, { 3, 3 } }); + NDarray cols = np.array(new int[,] { { 0, 2 }, { 0, 2 } }); + + var b = test[rows, cols]; + // should return + // [[0, 2], + // [9, 11]] + Assert.AreEqual("array([[ 0, 2],\n [ 9, 11]])", b.repr); + } + + [TestMethod] + public void IssueByAmpangboy() + { + var arr = np.array(1.0); + var result = np.insert(arr, 0, 1.0); + Assert.AreEqual("array([1., 1.])", result.repr); + } + + [TestMethod] + public void IssueByBigpo() + { + var a = np.random.randn(3, 3); + var tmp = np.linalg.qr(a); + } + + [TestMethod] + public void IssueByAllenP() + { + //>>> dx = 4.0 + //>>> dy = 5.0 + //>>> zX =[[1, 2, 3],[4,5,6],[8,9,0]] + //>>> np.gradient(zX, dx, dy) + //[array([[0.75, 0.75, 0.75], + // [0.875, 0.875, -0.375], + // [1. , 1. , -1.5]]), array([[0.2, 0.2, 0.2], + // [ 0.2, 0.2, 0.2], + // [ 0.2, -0.8, -1.8]])] + var zX = new NDarray(new[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 8, 9, 0 } }); + var result = np.gradient(zX, new List { 4.0, 5.0 }); + var expected = @"[array([[ 0.75 , 0.75 , 0.75 ], + [ 0.875, 0.875, -0.375], + [ 1. , 1. , -1.5 ]]), array([[ 0.2, 0.2, 0.2], + [ 0.2, 0.2, 0.2], + [ 0.2, -0.8, -1.8]])]".Replace("\r", ""); + Assert.AreEqual(expected, result.repr); + } + + [TestMethod] + public void PrimitiveConversion() + { + dynamic np = Numpy.np.dynamic_self; + Assert.AreEqual(3, (new PyInt(3)).As()); + Assert.AreEqual(1_000_000_000_000_000, new PyInt(1_000_000_000_000_000).As()); + Console.WriteLine(((dynamic)new PyInt(1_000_000_000_000_000)).__class__); // => + Console.WriteLine(np.int64(1_000_000_000_000_000).__class__); // => + Assert.AreEqual(3, (np.int32(3).item() as PyObject).As()); + Assert.AreEqual(1_000_000_000_000_000, (np.int64(1_000_000_000_000_000).item() as PyObject).As()); + } + + [TestMethod] + public void IssueByMegawattFs() + { + var arr = np.array(new int[] { 1, 2, 3, 4, 5 }); + var slice0 = new Slice(2, 4); + var arr4 = arr[slice0]; + Assert.AreEqual("array([3, 4])", arr4.repr); + var slice1 = new Slice(2, -1); + var arr5 = arr[slice1]; + Assert.AreEqual("array([3, 4])", arr5.repr); + var arr1 = arr["2:4"]; + Assert.AreEqual("array([3, 4])", arr1.repr); + var arr2 = arr[":4"]; + Assert.AreEqual("array([1, 2, 3, 4])", arr2.repr); + var arr3 = arr[":-1"]; + Assert.AreEqual("array([1, 2, 3, 4])", arr3.repr); + } + + [TestMethod] + public async Task IssueByMrCOrrupted() + { + Dictionary arrays = new Dictionary(); + arrays["a"] = np.arange(6).reshape(2, 3); + arrays["b"] = np.arange(3); + + var filename = Path.Combine(Path.GetTempPath(), "test.npz"); + np.savez_compressed(filename, null, arrays); + var archive = np.load(filename); + Console.WriteLine(archive.repr); + var a = new NDarray(archive.PyObject["a"]); + var b = new NDarray(archive.PyObject["b"]); + Console.WriteLine(a.repr); + Console.WriteLine(b.repr); + Assert.AreEqual("array([[0, 1, 2],\n [3, 4, 5]])", a.repr); + Assert.AreEqual(@"array([0, 1, 2])", b.repr); + } + + [TestMethod] + public async Task AsscalarRemovedInNumpyV1_23() + { + Assert.AreEqual(143, new NDarray(new int[] { 143 }).asscalar()); + Assert.AreEqual(143d, new NDarray(new[] { 143d }).asscalar()); + Assert.AreEqual(143d, new NDarray(new[] { 143d }).item()); + } + + [TestMethod] + public async Task IssueByMaLichtenegger() + { + // byte array als uint32 array + var bytes = new byte[] { 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0 }; + var uints = np.zeros(new Shape(3), np.uint32); + Console.WriteLine(uints.repr); + var ctypes = uints.PyObject.ctypes; + long ptr = ctypes.data; + Marshal.Copy(bytes, 0, new IntPtr(ptr), bytes.Length); + Console.WriteLine(uints.repr); + Assert.AreEqual("array([1, 2, 3], dtype=uint32)", uints.repr); + // byte array als float64 array + bytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0 }; + var doubles = np.zeros(new Shape(2), np.float64); + Console.WriteLine(doubles.repr); + ctypes = doubles.PyObject.ctypes; + ptr = ctypes.data; + Marshal.Copy(bytes, 0, new IntPtr(ptr), bytes.Length); + Console.WriteLine(doubles.repr); + Assert.IsTrue(doubles[0].asscalar() != 0); + Assert.IsTrue(doubles[1].asscalar() == 0); + } + + [TestMethod] + public async Task IssueByMartinDevans() + { + //>>> x = np.arange(9) + //>>> np.split(x, 3) + //[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])] + var x = np.arange(9); + var b = np.split(x, 3).repr(); + var a = "(array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8]))"; + Assert.AreEqual(a, b); + Assert.AreEqual(a, x.split(3, axis: -1).repr()); + //>>> x = np.arange(8.0) + //>>> np.split(x, [3, 5, 6, 10]) + //[array([0., 1., 2.]), + //array([3., 4.]), + //array([5.]), + //array([6., 7.]), + //array([], dtype = float64)] + x = np.arange(8); + b = np.split(x, new[] { 3, 5, 6, 10 }).repr(); + a = "(array([0, 1, 2]), array([3, 4]), array([5]), array([6, 7]), array([], dtype=int32))"; + Assert.AreEqual(a, b); + Assert.AreEqual(a, x.split(new[] { 3, 5, 6, 10 }).repr()); + } + + + [TestMethod] + public async Task F16Workaround() + { + // use byte array to create float16 array + + // numbers in float16: + // 0 01111 0000000000 = 2^0 * (1 + 0/1024) = 1 + // 1 01111 0000000000 = -1 * 2 ^ 0 * (1 + 0 / 1024) = -1 + // 0 11110 1111111111 = -1^(0) * 2^(15) * (1 + 1023/1024) ≈ 65504 + // see: https://devblogs.microsoft.com/dotnet/introducing-the-half-type/ + + // these bytes in binary notation correspond to f16 numbers 1, -1 and 65504 (float16 max value) + // note, the bytes are in reversed order to the bits shown above + var bytes = new byte[] { + 0b00000000, 0b00111100, // 1 + 0b00000000, 0b10111100, // -1 + 0b11111111, 0b01111011, // 65504 + }; + var floats = np.zeros(new Shape(3), np.float16); + Console.WriteLine(floats.repr); + // note, the using prevents a mem-leak with ctypes + using (var ctypes = floats.PyObject.ctypes) { + long ptr = ctypes.data; + Marshal.Copy(bytes, 0, new IntPtr(ptr), bytes.Length); + } + Console.WriteLine(floats.repr); + Assert.AreEqual("array([ 1.00e+00, -1.00e+00, 6.55e+04], dtype=float16)", floats.repr); + } + + + [TestMethod] + public async Task IssueByTimiil() + { + //>>> img = np.arange(27).reshape(3, 3, 3) + //>>> img + //array([[[0, 1, 2], + // [ 3, 4, 5], + // [ 6, 7, 8]], + + // [[ 9, 10, 11], + // [12, 13, 14], + // [15, 16, 17]], + + // [[18, 19, 20], + // [21, 22, 23], + // [24, 25, 26]]]) + //>>> fft_img = np.fft.fft2(img) + //>>> fft_img = np.fft.fftshift(fft_img) + //>>> fft_img + //array([[[0. + 0.j, -13.5 - 7.79422863j, 0. + 0.j], + // [ -4.5 - 2.59807621j, 198. + 0.j , -4.5 + 2.59807621j], + // [ 0. + 0.j , -13.5 + 7.79422863j, 0. + 0.j ]], + + // [[ 0. + 0.j , -13.5 - 7.79422863j, 0. + 0.j ], + // [ -4.5 - 2.59807621j, 36. + 0.j , -4.5 + 2.59807621j], + // [ 0. + 0.j , -13.5 + 7.79422863j, 0. + 0.j ]], + + // [[ 0. + 0.j , -13.5 - 7.79422863j, 0. + 0.j ], + // [ -4.5 - 2.59807621j, 117. + 0.j , -4.5 + 2.59807621j], + // [ 0. + 0.j , -13.5 + 7.79422863j, 0. + 0.j ]]]) + var img = np.arange(27).reshape(3, 3, 3); + var fft_img = np.fft.fft2(img); + fft_img = np.fft.fftshift(fft_img); + Console.WriteLine(fft_img.repr); + Assert.AreEqual(@"array([[[ 0. +0.j , -13.5-7.79422863j, 0. +0.j ], + [ -4.5-2.59807621j, 198. +0.j , -4.5+2.59807621j], + [ 0. +0.j , -13.5+7.79422863j, 0. +0.j ]], + + [[ 0. +0.j , -13.5-7.79422863j, 0. +0.j ], + [ -4.5-2.59807621j, 36. +0.j , -4.5+2.59807621j], + [ 0. +0.j , -13.5+7.79422863j, 0. +0.j ]], + + [[ 0. +0.j , -13.5-7.79422863j, 0. +0.j ], + [ -4.5-2.59807621j, 117. +0.j , -4.5+2.59807621j], + [ 0. +0.j , -13.5+7.79422863j, 0. +0.j ]]])".Replace("\r", ""), fft_img.repr); + } + + [TestMethod] + public void IssueByPandath() + { + //>>> grid = np.array([[1, 2, 3, 0, 0, 4], [5, 6, 7, 0, 0, 8]]) + //>>> xs, ys = np.where(grid == 0) + //>>> xs + //array([0, 0, 1, 1], dtype = int64) + //>>> ys + //array([3, 4, 3, 4], dtype = int64) + + var grid = np.array(new[,] { { 1, 2, 3, 0, 0, 4 }, { 5, 6, 7, 0, 0, 8 } }); + var result = np.where(grid.equals(0)); + Console.WriteLine(result[0].repr); + Console.WriteLine(result[1].repr); + Assert.AreEqual("array([0, 0, 1, 1], dtype=int64)", result[0].repr); + Assert.AreEqual("array([3, 4, 3, 4], dtype=int64)", result[1].repr); + } + + [TestMethod] + public void IssueByXiaozhu1988() + { + //>>> data = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]) + //>>> (data >= 50) & (data < 100) + //array([False, False, False, False, True, True, True, True, True, + // False, False, False]) + + var data = np.array(new[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120 }); + Console.WriteLine(((data >= 50) & (data < 100)).repr); + Assert.AreEqual("array([False, False, False, False, True, True, True, True, True,\n False, False, False])", ((data >= 50) & (data < 100)).repr); + Console.WriteLine(((data >= 50) | (data < 100)).repr); + Assert.AreEqual("array([ True, True, True, True, True, True, True, True, True,\n True, True, True])", ((data >= 50) | (data < 100)).repr); + Console.WriteLine(((data >= 50) ^ (data < 100)).repr); + Assert.AreEqual("array([ True, True, True, True, False, False, False, False, False,\n True, True, True])", ((data >= 50) ^ (data < 100)).repr); + } + + [TestMethod] + public void IssueByElinLiu0() + { + var x = np.array(new float[,] { { 1.1f, 2.2f }, { 3.141596f, 4.4f } }); + var y = string.Join(',', x.GetData().Select(z => z.ToString(CultureInfo.InvariantCulture))); + Console.WriteLine("Proof: " + y); + Assert.AreEqual("1.1,2.2,3.141596,4.4", y); + } + } + + + + + // TODO: https://docs.scipy.org/doc/numpy/user/basics.indexing.html?highlight=slice#structural-indexing-tools // TODO: https://docs.scipy.org/doc/numpy/user/basics.indexing.html?highlight=slice#assigning-values-to-indexed-arrays // TODO: https://docs.scipy.org/doc/numpy/user/basics.indexing.html?highlight=slice#dealing-with-variable-numbers-of-indices-within-programs -} + }