import { List } from "./List";
import { PrintObject } from "../models/PrintObject";
import { Reducer } from "../models/Reducer";
import { Number } from "./Number";
/**
 * @class gve.Array
 * @since gve
 */
export class Array<T> extends PrintObject {
  /**
   * 创建Array实例
   * @hideconstructor
   * @param {Array<Object> | Object} [args] 数值或Js的数组对象
   * @returns gve.Array
   */
  constructor(args?: Array<Object> | Object) {
    super();
    if (args) {
      this.geeList = args;
    }
    if (!(this instanceof Array)) {
      return new Array(args);
    }

  }

  geeList: Array<Object> | Object;

  static Array(list?: Array<Object> | Object) {
    return new Array(list);
  }

  /**
   *  返回正弦值
   *  @return Array
   */
  sin() {
    return new Array();
  }

  /**
   *  返回余弦值
   *  @return Array
   */
  cos() {
    return new Array();
  }

  /**
   *  返回正切值
   *  @return Array
   */
  tan() {
    return new Array();
  }

  /**
   *  返回平方根
   *  @return Array
   */
  sqrt() {
    return new Array();
  }

  /**
   * 返回绝对值
   * @returns Array
   */
  abs() {
    return new Array();
  }

  /**
   *  返回反正弦值
   *  @return Array
   */
  arcsin() {
    return new Array();
  }

  /**
   *  返回反余弦值
   *  @return Array
   */
  arccos() {
    return new Array();
  }

  /**
   *  返回反正切值
   *  @return Array
   */
  arctan() {
    return new Array();
  }

  /**
   *  返回双曲正弦值
   *  @return Array
   */
  sinh() {
    return new Array();
  }

  /**
   *  返回双曲余弦值
   *  @return Array
   */
  cosh() {
    return new Array();
  }

  /**
   *  返回双曲正切值
   *  @return Array
   */
  tanh() {
    return new Array();
  }

  /**
   *  返回双曲反正弦值
   *  @return Array
   */
  arcsinh() {
    return new Array();
  }

  /**
   *  返回双曲反余弦值
   *  @return Array
   */
  arccosh() {
    return new Array();
  }

  /**
   *  返回双曲反正切值
   *  @return Array
   */
  arctanh() {
    return new Array();
  }

  /**
   *  以元素为单位，向上取整
   *  @return Array
   */
  ceil() {
    return new Array();
  }

  /**
   *  以元素为单位，向下取整
   *  @return Array
   */
  floor() {
    return new Array();
  }

  /**
   *  以元素为单位，计算自然对数
   *  @return Array
   */
  log() {
    return new Array();
  }

  /**
   *  以元素为单位，返回以 10 为底的对数
   *  @return Array
   */
  log10() {
    return new Array();
  }

  /**
   *  以元素为单位，返回三次方根
   *  @return Array
   */
  cbrt() {
    return new Array();
  }

  /**
   *  以元素为单位，返回e的幂次方，e是一个常数为2.71828
   *  @return Array
   */
  exp() {
    return new Array();
  }

  /**
   *  以元素为单位，返回最接近的整数
   *  @return Array
   */
  round() {
    return new Array();
  }

  /**
   *  以元素为单位，返回数的符号
   *  @return Array
   */
  signum() {
    return new Array();
  }

  /**
   *  以元素为单位，返回8位无符号整数
   *  @return Array
   */
  uint8() {
    return new Array();
  }

  /**
   *  以元素为单位，返回16位无符号整数
   *  @return Array
   */
  uint16() {
    return new Array();
  }

  /**
   *  以元素为单位，返回32位无符号整数
   *  @return Array
   */
  uint32() {
    return new Array();
  }

  /**
   *  以元素为单位，返回64位无符号整数
   *  @return Array
   */
  uint64() {
    return new Array();
  }

  /**
   *  以元素为单位，返回整数
   *  @return Array
   */
  int() {
    return new Array();
  }

  /**
   *  以元素为单位，返回8位整数
   *  @return Array
   */
  int8() {
    return new Array();
  }

  /**
   *  以元素为单位，返回16位整数
   *  @return Array
   */
  int16() {
    return new Array();
  }

  /**
   *  以元素为单位，返回32位整数
   *  @return Array
   */
  int32() {
    return new Array();
  }

  /**
   *  以元素为单位，返回64位整数
   *  @return Array
   */
  int64() {
    return new Array();
  }

  /**
   *  以元素为单位，返回16位浮点数
   *  @return Array
   */
  float16() {
    return new Array();
  }

  /**
   *  以元素为单位，返回32位浮点数
   *  @return Array
   */
  float32() {
    return new Array();
  }

  /**
   *  以元素为单位，返回64位浮点数
   *  @return Array
   */
  float64() {
    return new Array();
  }

  /**
   *  以元素为单位，返回索引整数
   *  @return Array
   */
  intp() {
    return new Array();
  }

  /**
   *  以元素为单位，返回索引无符号整数
   *  @return Array
   */
  uintp() {
    return new Array();
  }

  /**
   *  以元素为单位，返回短整形
   *  @return Array
   */
  short() {
    return new Array();
  }

  /**
   *  以元素为单位，返回长整形
   *  @return Array
   */
  long() {
    return new Array();
  }

  /**
   *  以元素为单位，返回双精度浮点型
   *  @return Array
   */
  double() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Uint8类型
   *  @return Array
   */
  toUint8() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Int8类型
   *  @return Array
   */
  toInt8() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Byte类型
   *  @return Array
   */
  toByte() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Short类型
   *  @return Array
   */
  toShort() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Int16类型
   *  @return Array
   */
  toInt16() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Int32类型
   *  @return Array
   */
  toInt32() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Long类型
   *  @return Array
   */
  toLong() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Int64类型
   *  @return Array
   */
  toInt64() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Uint32类型
   *  @return Array
   */
  toUint32() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Double类型
   *  @return Array
   */
  toDouble() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Float类型
   *  @return Array
   */
  toFloat() {
    return new Array();
  }

  /**
   *  以元素为单位，转换为Int类型
   *  @return Array
   */
  toInt() {
    return new Array();
  }

  /**
   *  数组元素相加
   *  @param {any[]} right 数组
   *  @return Array
   */
  add(right: any[]) {
    return new Array();
  }

  /**
   *  返回欧几里德范数
   *  @param {any[]} right 数组
   *  @return Array
   */
  hypot(right: any[]) {
    return new Array();
  }

  /**
   *  数组元素相减
   *  @param {any[]} right 数组
   *  @return Array
   */
  subtract(right: any[]) {
    return new Array();
  }

  /**
   *  以元素为单位，做左边矩阵与右边矩阵的取余运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  mod(right: any[]) {
    return new Array();
  }



  /**
   *  以元素为单位，返回次方值
   *  @param {any[]} right 数组
   *  @return Array
   */
  pow(right: any[]) {
    return new Array();
  }

  /**
   *  以元素为单位，返回最大值
   *  @param {any[]} right 数组
   *  @return Array
   */
  max(right: any[]) {
    return new Array();
  }

  /**
   *  以元素为单位，返回最小值
   *  @param {any[]} right 数组
   *  @return Array
   */
  min(right: any[]) {
    return new Array();
  }

  /**
   *  返回整型变量i转化成二进制表示时1的个数
   *  @param {any[]} right 数组
   *  @return Array
   */
  bitCount(right: any[]) {
    return new Array();
  }

  /**
   *  计算输入数组中整数的基础二进制表示的按位与
   *  @param {any[]} right 数组
   *  @return Array
   */
  bitwiseAnd(right: any[]) {
    return new Array();
  }

  /**
   *  计算输入数组中整数的基础二进制表示的按位非
   *  @param {any[]} right 数组
   *  @return Array
   */
  bitwiseNot(right: any[]) {
    return new Array();
  }

  /**
   *  计算输入数组中整数的基础二进制表示的按位异或
   *  @param {any[]} right 数组
   *  @return Array
   */
  bitwiseXor(right: any[]) {
    return new Array();
  }

  /**
   *  计算输入数组中整数的基础二进制表示的按位或
   *  @param {any[]} right 数组
   *  @return Array
   */
  bitwiseOr(right: any[]) {
    return new Array();
  }

  /**
   *  以每个元素为单位，进行异或运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  xor(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行相等运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  eq(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行不相等运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  neq(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行小于运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  lt(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行小于等于运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  lte(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行大于运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  gt(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行大于等于运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  gte(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行与运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  and(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行或运算
   *  @param {any[]} right 数组
   *  @return Array
   */
  or(right: any[]) {
    return new Array();
  }

  /**
   * 以每个元素为单位，进行非运算
   * @param {any[]} right 数组
   * @return Array
   */
  not(right: any[]) {
    return new Array();
  }

  /**
   * DiGamma函数
   * @param {any[]} right 数组
   * @return Array
   */
  digamma(right: any[]) {
    return new Array();
  }

  /**
   * Gamma函数
   * @param {any[]} right 数组
   * @return Array
   */
  gamma(right: any[]) {
    return new Array();
  }

  /**
   * 不完全Gamma函数
   * @param {any[]} right 数组
   * @return Array
   */
  gammainc(right: any[]) {
    return new Array();
  }

  /**
   * TriGamma函数
   * @param {any[]} right 数组
   * @return Array
   */
  trigamma(right: any[]) {
    return new Array();
  }

  /**
   *  Array转换为List
   *  @return List
   */
  toList() {
    return new List([]);
  }
  /**
   *  获取Array长度。
   *  @return Array
   */
  length() {
    return new Array();
  }

  /**
 * 对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值
 * @param {Reducer} reducer Reducer实例
 * @param {number[]} axes 要应用Reducer的轴列表
 * @return Array
 */
  reduce(reducer: Reducer, axes: number[]) {
    return new Array();
  }

  /**
  * 对数组的元素进行排序，并返回对相同数组的引用。默认排序是将元素转换为字符串，然后按照它们的 UTF-16 码元值升序排序。
  * @param {any[]} keys 以给定的key对数组的元素进行排序
  *  @return Array
  */
  sort(keys?: any[] | List<T>) {
    return new Array();
  }

  /**
   *  以元素为基础，将第一个值乘以第二个值
   *  @param {any[]} right 右边的值
   *  @return Array
   */
  multiply(right: number[] | Array<T>) {

    return new Array();
  }

  /**
  *  从输入数组中提取给定位置的值
  *  @param {any[]} position 要提取元素的位置列表
  *  @return Number
  */
  get(position: number[]) {
    return new Number();

  }


  /**
*   通过按“step”的增量沿给定轴从“start”（包含）到“end”（不包含）的每个位置切片，创建子阵列。结果将具有与输入一样多的维度，并且在除切片轴之外的所有方向上的长度都相同，其中长度是从“start”到“end”根据在沿“axis”轴的输入数组长度范围内的“step”得到的位置数。这意味着，如果start = end，或者start或end值完全超出范围，则结果为沿着给定轴的长度0。
 *  @param {Int} [axis] 轴
 *  @param {Int} [start] 沿“axis”的第一个切片（包括第一个切片）的坐标。负数用于表示切片的开始位置相对于数组末尾的位置，其中-1表示从轴上的最后一个位置开始，-2表示从倒数第二个位置开始，依此类推。默认值为0
 *  @param {Int} [end] 停止切片的坐标（不包含切片）。默认情况下，值为给定轴的长度。负数用于表示切片的结束位置相对于数组末尾的位置，其中-1将排除最后一个位置，-2将排除最后两个位置，依此类推。默认值为null
 *  @param {Int} [step] 沿“轴”的每个切片之间的间隔；从“start”（包括在内）到“end”（不包括在内）的每一个“step”的整数倍处都将取一个切片。值必须为正整数。默认值为1
*  @return Array
*/
  slice(axis?: number, start?: number, end?: number, step?: number) {
    return new Array();
  }

  /**
   *  返回array中最大值所在的位置
   *  @return Number
   */
  argmax() {
    return new Number();
  }

  /**
  *  array 除法
  *  @param {any[]} right Array实例
  *  @return Array
  */
  divide(right: any[] | Array<T>) {
    return new Array();
  }

  /**
   *  计算矩阵的Cholesky分解
   *  @return Array
   */
  matrixCholeskyDecomposition() {
    return new Array();
  }

  /**
   *  计算矩阵的行列式
   *  @return Array
   */
  matrixDeterminant() {
    return new Array();
  }

  /**
   *  在单列中计算矩阵的对角线
   *  @return Array
   */
  matrixDiagonal() {
    return new Array();
  }

  /**
   *  计算矩阵的Frobenius范数
   *  @return Array
   */
  matrixFnorm() {
    return new Array();
  }

  /**
   *  计算矩阵的逆
   *  @return Array
   */
  matrixInverse() {
    return new Array();
  }

  /**
   *  计算LU矩阵分解
   *  @return Array
   */
  matrixLUDecomposition() {
    return new Array();
  }

  /**
   * 返回矩阵乘法A * B
  *  @param {any[]} right Array实例
   * @return Array
   */
  matrixMultiply(right: any[] | Array<T>) {
    return new Array();
  }

  /**
   *  计算矩阵的Moore-Penrose伪逆
   *  @return Array
   */
  matrixPseudoInverse() {
    return new Array();
  }

  /**
   *  计算一个矩阵的QR分解为两个矩阵Q和R，使得输入= QR，其中Q是正交的，R是上三角的
   *  @return Array
   */
  matrixQRDecomposition() {
    return new Array();
  }

  /**
   *  将输入矩阵的奇异值分解计算为U×S×V
   *  @return Array
   */
  matrixSingularValueDecomposition() {
    return new Array();
  }

  /**
   *  求解矩阵方程A * x = B中的x，在A超定时求最小二乘解
   *  @return Array
   */
  matrixSolve() {
    return new Array();
  }

  /**
   *  从单列矩阵计算一个对角线矩阵
   *  @return Array
   */
  matrixToDiag() {
    return new Array();
  }

  /**
   *  计算矩阵的迹
   *  @return Array
   */
  matrixTrace() {
    return new Array();
  }

  /**
   *  对数组的两个维度进行转置
   *  @return Array
   */
  matrixTranspose() {
    return new Array();
  }

  /**
   * 将多个相同维度的Array按照给定轴方向连接到一个Array中
   * @param {List|any[]} arrays 多个待连接的Array列表
   * @param {number} [axis] 可选参数，给定轴
   * @returns Array
   * @tutorial gve.Array
   */
  static cat(arrays: List<any>|any[], axis?:number) {
    return new Array();
  }

  /**
   * 结果元素是给定轴方向每个元素的累积操作
   * @param {number} axis 沿轴进行积累的轴
   * @param {Reducer} [reducer] 可选参数，给定轴方向累积值
   * @returns Array
   */
  accum(axis: number, reducer?:Reducer) {
    return new Array();
  }


  /**
   * 通过在输入数组中切片与给定掩膜数组的非零元素平行的输入数组中的每个位置来创建子阵列。
   * @param {any[]} mask  掩膜数组
   * @returns Array
   */
  mask(mask:any[]|Array<T>){
    return new Array();
  }
  /**
   * 沿给定轴重复数组
   * @param {Number} [axis]  重复数组的轴
   * @param {Number} [copies]  该数组的副本数量沿给定轴连接
   * @returns Array
   */
  repeat(axis?:Number|number, copies?:Number|number){
    return new Array();
  }
  /**
   * 转置阵列的两个维度
   * @param {Number} [axis1]  转置的第一个轴方向
   * @param {Number} [axis2]  转置的第二个轴方向
   * @returns Array
   */
  transpose(axis1?:Number|number, axis2?:Number|number){
    return new Array();
  }

  /**
   * 创建给定大小的二维矩阵
   * @param {Number} size 待创建矩阵的大小
   * @returns  Array
   * @tutorial gve.Array
   */
  static identity(size:number){
    return new Array();
  }


}