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

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
            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", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns an array with the number of non-overlapping occurrences of
        ///	substring sub in the range [start, end].<br></br>
        ///	
        ///	Calls str.count element-wise.
        /// </summary>
        /// <param name="sub">
        ///	The substring to search for.
        /// </param>
        /// <param name="end">
        ///	Optional arguments start and end are interpreted as slice
        ///	notation to specify the range in which to count.
        /// </param>
        /// <param name="start">
        ///	Optional arguments start and end are interpreted as slice
        ///	notation to specify the range in which to count.
        /// </param>
        /// <returns>
        ///	Output array of ints.
        /// </returns>
        public NDarray core_defchararray_count(string[] a, string sub, int? end = null, int? start = 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,
                sub,
            });
            var kwargs=new PyDict();
            if (end!=null) kwargs["end"]=ToPython(end);
            if (start!=null) kwargs["start"]=ToPython(start);
            dynamic py = __self__.InvokeMethod("count", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	For each element, return the lowest index in the string where
        ///	substring sub is found.<br></br>
        ///	
        ///	Calls str.find element-wise.<br></br>
        ///	
        ///	For each element, return the lowest index in the string where
        ///	substring sub is found, such that sub is contained in the
        ///	range [start, end].
        /// </summary>
        /// <param name="end">
        ///	Optional arguments start and end are interpreted as in
        ///	slice notation.
        /// </param>
        /// <param name="start">
        ///	Optional arguments start and end are interpreted as in
        ///	slice notation.
        /// </param>
        /// <returns>
        ///	Output array of ints.<br></br>
        ///	  Returns -1 if sub is not found.
        /// </returns>
        public NDarray core_defchararray_find(string[] a, string sub, int? end = null, int? start = 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,
                sub,
            });
            var kwargs=new PyDict();
            if (end!=null) kwargs["end"]=ToPython(end);
            if (start!=null) kwargs["start"]=ToPython(start);
            dynamic py = __self__.InvokeMethod("find", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Like find, but raises ValueError when the substring is not found.<br></br>
        ///	
        ///	Calls str.index element-wise.
        /// </summary>
        /// <returns>
        ///	Output array of ints.<br></br>
        ///	  Returns -1 if sub is not found.
        /// </returns>
        public NDarray core_defchararray_index(string[] a, string sub, int? end = null, int? start = 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,
                sub,
            });
            var kwargs=new PyDict();
            if (end!=null) kwargs["end"]=ToPython(end);
            if (start!=null) kwargs["start"]=ToPython(start);
            dynamic py = __self__.InvokeMethod("index", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns true for each element if all characters in the string are
        ///	alphabetic and there is at least one character, false otherwise.<br></br>
        ///	
        ///	Calls str.isalpha element-wise.<br></br>
        ///	
        ///	For 8-bit strings, this method is locale-dependent.
        /// </summary>
        /// <returns>
        ///	Output array of bools
        /// </returns>
        public NDarray core_defchararray_isalpha(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("isalpha", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	For each element, return True if there are only decimal
        ///	characters in the element.<br></br>
        ///	
        ///	Calls unicode.isdecimal element-wise.<br></br>
        ///	
        ///	Decimal characters include digit characters, and all characters
        ///	that that can be used to form decimal-radix numbers,
        ///	e.g.<br></br>
        ///	 U+0660, ARABIC-INDIC DIGIT ZERO.
        /// </summary>
        /// <param name="a">
        ///	Input array.
        /// </param>
        /// <returns>
        ///	Array of booleans identical in shape to a.
        /// </returns>
        public NDarray core_defchararray_isdecimal(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("isdecimal", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns true for each element if all characters in the string are
        ///	digits and there is at least one character, false otherwise.<br></br>
        ///	
        ///	Calls str.isdigit element-wise.<br></br>
        ///	
        ///	For 8-bit strings, this method is locale-dependent.
        /// </summary>
        /// <returns>
        ///	Output array of bools
        /// </returns>
        public NDarray core_defchararray_isdigit(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("isdigit", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns true for each element if all cased characters in the
        ///	string are lowercase and there is at least one cased character,
        ///	false otherwise.<br></br>
        ///	
        ///	Calls str.islower element-wise.<br></br>
        ///	
        ///	For 8-bit strings, this method is locale-dependent.
        /// </summary>
        /// <returns>
        ///	Output array of bools
        /// </returns>
        public NDarray core_defchararray_islower(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("islower", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	For each element, return True if there are only numeric
        ///	characters in the element.<br></br>
        ///	
        ///	Calls unicode.isnumeric element-wise.<br></br>
        ///	
        ///	Numeric characters include digit characters, and all characters
        ///	that have the Unicode numeric value property, e.g.<br></br>
        ///	 U+2155,
        ///	VULGAR FRACTION ONE FIFTH.
        /// </summary>
        /// <param name="a">
        ///	Input array.
        /// </param>
        /// <returns>
        ///	Array of booleans of same shape as a.
        /// </returns>
        public NDarray core_defchararray_isnumeric(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("isnumeric", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns true for each element if there are only whitespace
        ///	characters in the string and there is at least one character,
        ///	false otherwise.<br></br>
        ///	
        ///	Calls str.isspace element-wise.<br></br>
        ///	
        ///	For 8-bit strings, this method is locale-dependent.
        /// </summary>
        /// <returns>
        ///	Output array of bools
        /// </returns>
        public NDarray core_defchararray_isspace(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("isspace", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns true for each element if the element is a titlecased
        ///	string and there is at least one character, false otherwise.<br></br>
        ///	
        ///	Call str.istitle element-wise.<br></br>
        ///	
        ///	For 8-bit strings, this method is locale-dependent.
        /// </summary>
        /// <returns>
        ///	Output array of bools
        /// </returns>
        public NDarray core_defchararray_istitle(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("istitle", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns true for each element if all cased characters in the
        ///	string are uppercase and there is at least one character, false
        ///	otherwise.<br></br>
        ///	
        ///	Call str.isupper element-wise.<br></br>
        ///	
        ///	For 8-bit strings, this method is locale-dependent.
        /// </summary>
        /// <returns>
        ///	Output array of bools
        /// </returns>
        public NDarray core_defchararray_isupper(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("isupper", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	For each element in a, return the highest index in the string
        ///	where substring sub is found, such that sub is contained
        ///	within [start, end].<br></br>
        ///	
        ///	Calls str.rfind element-wise.
        /// </summary>
        /// <param name="end">
        ///	Optional arguments start and end are interpreted as in
        ///	slice notation.
        /// </param>
        /// <param name="start">
        ///	Optional arguments start and end are interpreted as in
        ///	slice notation.
        /// </param>
        /// <returns>
        ///	Output array of ints.<br></br>
        ///	  Return -1 on failure.
        /// </returns>
        public NDarray core_defchararray_rfind(string[] a, string sub, int? end = null, int? start = 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,
                sub,
            });
            var kwargs=new PyDict();
            if (end!=null) kwargs["end"]=ToPython(end);
            if (start!=null) kwargs["start"]=ToPython(start);
            dynamic py = __self__.InvokeMethod("rfind", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Like rfind, but raises ValueError when the substring sub is
        ///	not found.<br></br>
        ///	
        ///	Calls str.rindex element-wise.
        /// </summary>
        /// <returns>
        ///	Output array of ints.
        /// </returns>
        public NDarray core_defchararray_rindex(string[] a, string sub, int? end = null, int? start = 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,
                sub,
            });
            var kwargs=new PyDict();
            if (end!=null) kwargs["end"]=ToPython(end);
            if (start!=null) kwargs["start"]=ToPython(start);
            dynamic py = __self__.InvokeMethod("rindex", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns a boolean array which is True where the string element
        ///	in a starts with prefix, otherwise False.<br></br>
        ///	
        ///	Calls str.startswith element-wise.
        /// </summary>
        /// <param name="end">
        ///	With optional start, test beginning at that position.<br></br>
        ///	With
        ///	optional end, stop comparing at that position.
        /// </param>
        /// <param name="start">
        ///	With optional start, test beginning at that position.<br></br>
        ///	With
        ///	optional end, stop comparing at that position.
        /// </param>
        /// <returns>
        ///	Array of booleans
        /// </returns>
        public NDarray core_defchararray_startswith(string[] a, string prefix, int? end = null, int? start = 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,
                prefix,
            });
            var kwargs=new PyDict();
            if (end!=null) kwargs["end"]=ToPython(end);
            if (start!=null) kwargs["start"]=ToPython(start);
            dynamic py = __self__.InvokeMethod("startswith", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Provides a convenient view on arrays of string and unicode values.<br></br>
        ///	
        ///	Versus a regular NumPy array of type str or unicode, this
        ///	class adds the following functionality:
        ///	
        ///	chararrays should be created using numpy.char.array or
        ///	numpy.char.asarray, rather than this constructor directly.<br></br>
        ///	
        ///	This constructor creates the array, using buffer (with offset
        ///	and strides) if it is not None.<br></br>
        ///	 If buffer is None, then
        ///	constructs a new array with strides in “C order”, unless both
        ///	len(shape) &gt;= 2 and order='Fortran', in which case strides
        ///	is in “Fortran order”.
        /// </summary>
        /// <param name="shape">
        ///	Shape of the array.
        /// </param>
        /// <param name="itemsize">
        ///	Length of each array element, in number of characters.<br></br>
        ///	Default is 1.
        /// </param>
        /// <param name="unicode">
        ///	Are the array elements of type unicode (True) or string (False).<br></br>
        ///	
        ///	Default is False.
        /// </param>
        /// <param name="buffer">
        ///	Memory address of the start of the array data.<br></br>
        ///	Default is None,
        ///	in which case a new array is created.
        /// </param>
        /// <param name="offset">
        ///	Fixed stride displacement from the beginning of an axis?
        ///	Default is 0.<br></br>
        ///	Needs to be &gt;=0.
        /// </param>
        /// <param name="strides">
        ///	Strides for the array (see ndarray.strides for full description).<br></br>
        ///	
        ///	Default is None.
        /// </param>
        /// <param name="order">
        ///	The order in which the array data is stored in memory: ‘C’ -&gt;
        ///	“row major” order (the default), ‘F’ -&gt; “column major”
        ///	(Fortran) order.
        /// </param>
        public void core_defchararray_chararray(Shape shape, int? itemsize = null, bool? unicode = null, int? buffer = null, int? offset = null, int[] strides = null, string order = 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[]
            {
                shape,
            });
            var kwargs=new PyDict();
            if (itemsize!=null) kwargs["itemsize"]=ToPython(itemsize);
            if (unicode!=null) kwargs["unicode"]=ToPython(unicode);
            if (buffer!=null) kwargs["buffer"]=ToPython(buffer);
            if (offset!=null) kwargs["offset"]=ToPython(offset);
            if (strides!=null) kwargs["strides"]=ToPython(strides);
            if (order!=null) kwargs["order"]=ToPython(order);
            dynamic py = __self__.InvokeMethod("chararray", pyargs, kwargs);
        }
        
    }
}