// Copyright (c) 2019 by the SciSharp Team

// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using Python.Runtime;

using Numpy.Models;

using Python.Included;

namespace Numpy

{

public partial class NumPy

{

/// <summary>

/// Return element-wise string concatenation for two arrays of str or unicode.<br></br>

///

/// Arrays x1 and x2 must have the same shape.

/// </summary>

/// <param name="x1">

/// Input array.

/// </param>

/// <param name="x2">

/// Input array.

/// </param>

/// <returns>

/// Output array of string_ or unicode_, depending on input types

/// of the same shape as x1 and x2.

/// </returns>

public NDarray core_defchararray_add(string[] x1, string[] x2)

{

//auto-generated code, do not change

var core = self.GetAttr("core");

var defchararray = core.GetAttr("defchararray");

var __self__=defchararray;

var pyargs=ToTuple(new object[]

{

x1,

x2,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return (a * i), that is string multiple concatenation,

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

///

/// Values in i of less than 0 are treated as 0 (which yields an

/// empty string).

/// </summary>

/// <returns>

/// Output array of str or unicode, depending on input types

/// </returns>

public NDarray core_defchararray_multiply(string[] a, int[] i)

{

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

i,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return (a % i), that is pre-Python 2.6 string formatting

/// (iterpolation), element-wise for a pair of array_likes of str

/// or unicode.

/// </summary>

/// <param name="values">

/// These values will be element-wise interpolated into the string.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input types

/// </returns>

public NDarray core_defchararray_mod(string[] a, NDarray values)

{

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

values,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return a copy of a with only the first character of each element

/// capitalized.<br></br>

///

/// Calls str.capitalize element-wise.<br></br>

///

/// For 8-bit strings, this method is locale-dependent.

/// </summary>

/// <param name="a">

/// Input array of strings to capitalize.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input

/// types

/// </returns>

public NDarray core_defchararray_capitalize(params string[] a)

{

//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();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return a copy of a with its elements centered in a string of

/// length width.<br></br>

///

/// Calls str.center element-wise.

/// </summary>

/// <param name="width">

/// The length of the resulting strings

/// </param>

/// <param name="fillchar">

/// The padding character to use (default is space).

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input

/// types

/// </returns>

public NDarray core_defchararray_center(string[] a, int width, string fillchar = " ")

{

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

width,

});

var kwargs=new PyDict();

if (fillchar!=" ") kwargs["fillchar"]=ToPython(fillchar);

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Calls str.decode element-wise.<br></br>

///

/// The set of available codecs comes from the Python standard library,

/// and may be extended at runtime.<br></br>

/// For more information, see the

/// codecs module.<br></br>

///

/// Notes

///

/// The type of the result will depend on the encoding specified.

/// </summary>

/// <param name="encoding">

/// The name of an encoding

/// </param>

/// <param name="errors">

/// Specifies how to handle encoding errors

/// </param>

public NDarray core_defchararray_decode(string[] a, string encoding = null, string errors = 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 (encoding!=null) kwargs["encoding"]=ToPython(encoding);

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

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Calls str.encode element-wise.<br></br>

///

/// The set of available codecs comes from the Python standard library,

/// and may be extended at runtime.<br></br>

/// For more information, see the codecs

/// module.<br></br>

///

/// Notes

///

/// The type of the result will depend on the encoding specified.

/// </summary>

/// <param name="encoding">

/// The name of an encoding

/// </param>

/// <param name="errors">

/// Specifies how to handle encoding errors

/// </param>

public NDarray core_defchararray_encode(string[] a, string encoding = null, string errors = 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 (encoding!=null) kwargs["encoding"]=ToPython(encoding);

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

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return a string which is the concatenation of the strings in the

/// sequence seq.<br></br>

///

/// Calls str.join element-wise.

/// </summary>

/// <returns>

/// Output array of str or unicode, depending on input types

/// </returns>

public NDarray core_defchararray_join(string[] sep, string[] seq)

{

//auto-generated code, do not change

var core = self.GetAttr("core");

var defchararray = core.GetAttr("defchararray");

var __self__=defchararray;

var pyargs=ToTuple(new object[]

{

sep,

seq,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return an array with the elements of a left-justified in a

/// string of length width.<br></br>

///

/// Calls str.ljust element-wise.

/// </summary>

/// <param name="width">

/// The length of the resulting strings

/// </param>

/// <param name="fillchar">

/// The character to use for padding

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_ljust(string[] a, int width, string fillchar = " ")

{

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

width,

});

var kwargs=new PyDict();

if (fillchar!=" ") kwargs["fillchar"]=ToPython(fillchar);

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return an array with the elements converted to lowercase.<br></br>

///

/// Call str.lower element-wise.<br></br>

///

/// For 8-bit strings, this method is locale-dependent.

/// </summary>

/// <param name="a">

/// Input array.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_lower(NDarray a)

{

//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();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// For each element in a, return a copy with the leading characters

/// removed.<br></br>

///

/// Calls str.lstrip element-wise.

/// </summary>

/// <param name="a">

/// Input array.

/// </param>

/// <param name="chars">

/// The chars argument is a string specifying the set of

/// characters to be removed.<br></br>

/// If omitted or None, the chars

/// argument defaults to removing whitespace.<br></br>

/// The chars argument

/// is not a prefix; rather, all combinations of its values are

/// stripped.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_lstrip(NDarray a, string chars = 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 (chars!=null) kwargs["chars"]=ToPython(chars);

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Partition each element in a around sep.<br></br>

///

/// Calls str.partition element-wise.<br></br>

///

/// For each element in a, split the element as the first

/// occurrence of sep, and return 3 strings containing the part

/// before the separator, the separator itself, and the part after

/// the separator.<br></br>

/// If the separator is not found, return 3 strings

/// containing the string itself, followed by two empty strings.

/// </summary>

/// <param name="a">

/// Input array

/// </param>

/// <param name="sep">

/// Separator to split each string element in a.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type.<br></br>

///

/// The output array will have an extra dimension with 3

/// elements per input element.

/// </returns>

public NDarray core_defchararray_partition(NDarray a, string sep)

{

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

sep,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// For each element in a, return a copy of the string with all

/// occurrences of substring old replaced by new.<br></br>

///

/// Calls str.replace element-wise.

/// </summary>

/// <param name="count">

/// If the optional argument count is given, only the first

/// count occurrences are replaced.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_replace(string[] a, string @new, string old, int? count = 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,

@new,

old,

});

var kwargs=new PyDict();

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

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return an array with the elements of a right-justified in a

/// string of length width.<br></br>

///

/// Calls str.rjust element-wise.

/// </summary>

/// <param name="width">

/// The length of the resulting strings

/// </param>

/// <param name="fillchar">

/// The character to use for padding

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_rjust(string[] a, int width, string fillchar = " ")

{

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

width,

});

var kwargs=new PyDict();

if (fillchar!=" ") kwargs["fillchar"]=ToPython(fillchar);

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Partition (split) each element around the right-most separator.<br></br>

///

/// Calls str.rpartition element-wise.<br></br>

///

/// For each element in a, split the element as the last

/// occurrence of sep, and return 3 strings containing the part

/// before the separator, the separator itself, and the part after

/// the separator.<br></br>

/// If the separator is not found, return 3 strings

/// containing the string itself, followed by two empty strings.

/// </summary>

/// <param name="a">

/// Input array

/// </param>

/// <param name="sep">

/// Right-most separator to split each element in array.

/// </param>

/// <returns>

/// Output array of string or unicode, depending on input

/// type.<br></br>

/// The output array will have an extra dimension with

/// 3 elements per input element.

/// </returns>

public NDarray core_defchararray_rpartition(string[] a, string sep)

{

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

sep,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// For each element in a, return a list of the words in the

/// string, using sep as the delimiter string.<br></br>

///

/// Calls str.rsplit element-wise.<br></br>

///

/// Except for splitting from the right, rsplit

/// behaves like split.

/// </summary>

/// <param name="sep">

/// If sep is not specified or None, any whitespace string

/// is a separator.

/// </param>

/// <param name="maxsplit">

/// If maxsplit is given, at most maxsplit splits are done,

/// the rightmost ones.

/// </param>

/// <returns>

/// Array of list objects

/// </returns>

public NDarray core_defchararray_rsplit(string[] a, string 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("rsplit", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// For each element in a, return a copy with the trailing

/// characters removed.<br></br>

///

/// Calls str.rstrip element-wise.

/// </summary>

/// <param name="chars">

/// The chars argument is a string specifying the set of

/// characters to be removed.<br></br>

/// If omitted or None, the chars

/// argument defaults to removing whitespace.<br></br>

/// The chars argument

/// is not a suffix; rather, all combinations of its values are

/// stripped.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_rstrip(string[] a, string chars = 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 (chars!=null) kwargs["chars"]=ToPython(chars);

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// For each element in a, return a list of the words in the

/// string, using sep as the delimiter string.<br></br>

///

/// Calls str.split element-wise.

/// </summary>

/// <param name="sep">

/// If sep is not specified or None, any whitespace string is a

/// separator.

/// </param>

/// <param name="maxsplit">

/// If maxsplit is given, at most maxsplit splits are done.

/// </param>

/// <returns>

/// Array of list objects

/// </returns>

public NDarray core_defchararray_split(string[] a, string 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<NDarray>(py);

}

/// <summary>

/// For each element in a, return a list of the lines in the

/// element, breaking at line boundaries.<br></br>

///

/// Calls str.splitlines element-wise.

/// </summary>

/// <param name="keepends">

/// Line breaks are not included in the resulting list unless

/// keepends is given and true.

/// </param>

/// <returns>

/// Array of list objects

/// </returns>

public NDarray core_defchararray_splitlines(string[] a, bool? keepends = 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 (keepends!=null) kwargs["keepends"]=ToPython(keepends);

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// For each element in a, return a copy with the leading and

/// trailing characters removed.<br></br>

///

/// Calls str.strip element-wise.

/// </summary>

/// <param name="chars">

/// The chars argument is a string specifying the set of

/// characters to be removed.<br></br>

/// If omitted or None, the chars

/// argument defaults to removing whitespace.<br></br>

/// The chars argument

/// is not a prefix or suffix; rather, all combinations of its

/// values are stripped.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_strip(string[] a, string chars = 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 (chars!=null) kwargs["chars"]=ToPython(chars);

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return element-wise a copy of the string with

/// uppercase characters converted to lowercase and vice versa.<br></br>

///

/// Calls str.swapcase element-wise.<br></br>

///

/// For 8-bit strings, this method is locale-dependent.

/// </summary>

/// <param name="a">

/// Input array.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_swapcase(NDarray a)

{

//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();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return element-wise title cased version of string or unicode.<br></br>

///

/// Title case words start with uppercase characters, all remaining cased

/// characters are lowercase.<br></br>

///

/// Calls str.title element-wise.<br></br>

///

/// For 8-bit strings, this method is locale-dependent.

/// </summary>

/// <param name="a">

/// Input array.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_title(NDarray a)

{

//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();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// For each element in a, return a copy of the string where all

/// characters occurring in the optional argument deletechars are

/// removed, and the remaining characters have been mapped through the

/// given translation table.<br></br>

///

/// Calls str.translate element-wise.

/// </summary>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_translate(string[] a, string table, string deletechars)

{

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

table,

deletechars,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return an array with the elements converted to uppercase.<br></br>

///

/// Calls str.upper element-wise.<br></br>

///

/// For 8-bit strings, this method is locale-dependent.

/// </summary>

/// <param name="a">

/// Input array.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_upper(NDarray a)

{

//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();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return the numeric string left-filled with zeros

///

/// Calls str.zfill element-wise.

/// </summary>

/// <param name="a">

/// Input array.

/// </param>

/// <param name="width">

/// Width of string to left-fill elements in a.

/// </param>

/// <returns>

/// Output array of str or unicode, depending on input type

/// </returns>

public NDarray core_defchararray_zfill(NDarray a, int width)

{

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

width,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return (x1 == x2) element-wise.<br></br>

///

/// Unlike numpy.equal, this comparison is performed by first

/// stripping whitespace characters from the end of the string.<br></br>

/// This

/// behavior is provided for backward-compatibility with numarray.

/// </summary>

/// <param name="x2">

/// Input arrays of the same shape.

/// </param>

/// <param name="x1">

/// Input arrays of the same shape.

/// </param>

/// <returns>

/// Output array of bools, or a single bool if x1 and x2 are scalars.

/// </returns>

public NDarray core_defchararray_equal(string[] x2, string[] x1)

{

//auto-generated code, do not change

var core = self.GetAttr("core");

var defchararray = core.GetAttr("defchararray");

var __self__=defchararray;

var pyargs=ToTuple(new object[]

{

x2,

x1,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return (x1 != x2) element-wise.<br></br>

///

/// Unlike numpy.not_equal, this comparison is performed by first

/// stripping whitespace characters from the end of the string.<br></br>

/// This

/// behavior is provided for backward-compatibility with numarray.

/// </summary>

/// <param name="x2">

/// Input arrays of the same shape.

/// </param>

/// <param name="x1">

/// Input arrays of the same shape.

/// </param>

/// <returns>

/// Output array of bools, or a single bool if x1 and x2 are scalars.

/// </returns>

public NDarray core_defchararray_not_equal(string[] x2, string[] x1)

{

//auto-generated code, do not change

var core = self.GetAttr("core");

var defchararray = core.GetAttr("defchararray");

var __self__=defchararray;

var pyargs=ToTuple(new object[]

{

x2,

x1,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return (x1 &gt;= x2) element-wise.<br></br>

///

/// Unlike numpy.greater_equal, this comparison is performed by

/// first stripping whitespace characters from the end of the string.<br></br>

///

/// This behavior is provided for backward-compatibility with

/// numarray.

/// </summary>

/// <param name="x2">

/// Input arrays of the same shape.

/// </param>

/// <param name="x1">

/// Input arrays of the same shape.

/// </param>

/// <returns>

/// Output array of bools, or a single bool if x1 and x2 are scalars.

/// </returns>

public NDarray core_defchararray_greater_equal(string[] x2, string[] x1)

{

//auto-generated code, do not change

var core = self.GetAttr("core");

var defchararray = core.GetAttr("defchararray");

var __self__=defchararray;

var pyargs=ToTuple(new object[]

{

x2,

x1,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return (x1 &lt;= x2) element-wise.<br></br>

///

/// Unlike numpy.less_equal, this comparison is performed by first

/// stripping whitespace characters from the end of the string.<br></br>

/// This

/// behavior is provided for backward-compatibility with numarray.

/// </summary>

/// <param name="x2">

/// Input arrays of the same shape.

/// </param>

/// <param name="x1">

/// Input arrays of the same shape.

/// </param>

/// <returns>

/// Output array of bools, or a single bool if x1 and x2 are scalars.

/// </returns>

public NDarray core_defchararray_less_equal(string[] x2, string[] x1)

{

//auto-generated code, do not change

var core = self.GetAttr("core");

var defchararray = core.GetAttr("defchararray");

var __self__=defchararray;

var pyargs=ToTuple(new object[]

{

x2,

x1,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return (x1 &gt; x2) element-wise.<br></br>

///

/// Unlike numpy.greater, this comparison is performed by first

/// stripping whitespace characters from the end of the string.<br></br>

/// This

/// behavior is provided for backward-compatibility with numarray.

/// </summary>

/// <param name="x2">

/// Input arrays of the same shape.

/// </param>

/// <param name="x1">

/// Input arrays of the same shape.

/// </param>

/// <returns>

/// Output array of bools, or a single bool if x1 and x2 are scalars.

/// </returns>

public NDarray core_defchararray_greater(string[] x2, string[] x1)

{

//auto-generated code, do not change

var core = self.GetAttr("core");

var defchararray = core.GetAttr("defchararray");

var __self__=defchararray;

var pyargs=ToTuple(new object[]

{

x2,

x1,

});

var kwargs=new PyDict();

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

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return (x1 &lt; x2) element-wise.<br></br>

///

/// Unlike numpy.greater, this comparison is performed by first

/// stripping whitespace characters from the end of the string.<br></br>

/// This

/// behavior is provided for backward-compatibility with numarray.

/// </summary>

/// <param name="x2">

/// Input arrays of the same shape.

/// </param>

/// <param name="x1">

/// Input arrays of the same shape.

/// </param>

/// <returns>

/// Output array of bools, or a single bool if x1 and x2 are scalars.

/// </returns>

public NDarray core_defchararray_less(string[] x2, string[] x1)

{

//auto-generated code, do not change