import { Dictionary } from "../models/Dictionary";
import { PrintObject } from "../models/PrintObject";
import { Boolean } from "./Boolean";
import { String } from "./String";

/**
 * @class gve.Number
 * @since gve
 */
export class Number extends PrintObject {

  /**
   * Number的构造方法，构造一个新数值
   * @hideconstructor
   * @param {Number|object} number 
   * @returns Number
   */
  constructor(number?: number | object) {
    super();
    if (number) {
      this.geeNumber = number;
    }
  }

  geeNumber: any;

  static Number(number?: number) {
    return new Number(number);
  }

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

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

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

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

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

  /**
   *  向上取整
   *  @return Number
   */
  ceil() {
    return new Number();
  }

  /**
   *  向下取整
   *  @return Number
   */
  floor() {
    return new Number();
  }

  /**
   *  自然对数
   *  @return Number
   */
  log() {
    return new Number();
  }

  /**
   *  返回以 10 为底的对数
   *  @return Number
   */
  log10() {
    return new Number();
  }

  /**
   *  返回三次方根
   *  @return Number
   */
  cbrt() {
    return new Number();
  }

  /**
   *  返回e的幂次方，e是一个常数为2.71828
   *  @return Number
   */
  exp() {
    return new Number();
  }

  /**
   *  返回最接近的整数
   *  @return Number
   */
  round() {
    return new Number();
  }

  /**
   *  返回数的符号
   *  @return Number
   */
  signum() {
    return new Number();
  }

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

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

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

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

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

  /**
   *  返回双曲反正切值, 定义域为(-1, 1)
   *  @return Number
   */
  arctanh() {
    if (this.geeNumber >= 1 || this.geeNumber <= -1) {
      throw new Error("arctanh的定义域为(-1, 1)");
    }
    return new Number();
  }

  /**
   *  判断是否符合bool8
   *  @return Boolean
   */
  bool8() {
    return new Boolean();
  }

  /**
   *  返回8位无符号整数
   *  @return Number
   */
  uint8() {
    return new Number();
  }

  /**
   *  返回16位无符号整数
   *  @return Number
   */
  uint16() {
    return new Number();
  }

  /**
   *  返回32位无符号整数
   *  @return Number
   */
  uint32() {
    return new Number();
  }

  /**
   *  返回64位无符号整数
   *  @return Number
   */
  uint64() {
    return new Number();
  }

  /**
   *  返回整数
   *  @return Number
   */
  int() {
    return new Number();
  }

  /**
   *  返回8位整数
   *  @return Number
   */
  int8() {
    return new Number();
  }

  /**
   *  返回16位整数
   *  @return Number
   */
  int16() {
    return new Number();
  }

  /**
   *  返回32位整数
   *  @return Number
   */
  int32() {
    return new Number();
  }

  /**
   *  返回64位整数
   *  @return Number
   */
  int64() {
    return new Number();
  }

  /**
   *  intp
   *  @return Number
   */
  intp() {
    return new Number();
  }

  /**
   *  uintp
   *  @return Number
   */
  uintp() {
    return new Number();
  }

  /**
   *  返回16位浮点数
   *  @return Number
   */
  float16() {
    return new Number();
  }

  /**
   *  返回32位浮点数
   *  @return Number
   */
  float32() {
    return new Number();
  }

  /**
   *  返回64位浮点数
   *  @return Number
   */
  float64() {
    return new Number();
  }

  /**
   *  返回浮点数
   *  @return Number
   */
  float() {
    return new Number();
  }

  /////////////////////////////

  /**
   *  返回短整形
   *  @return Number
   */
  short() {
    return new Number();
  }

  /**
   *  返回长整形
   *  @return Number
   */
  long() {
    return new Number();
  }

  /**
   *  返回双精度浮点型
   *  @return Number
   */
  double() {
    return new Number();
  }

  /**
   *  转换为Uint8类型
   *  @return Number
   */
  toUint8() {
    return new Number();
  }

  /**
   *  转换为Int8类型
   *  @return Number
   */
  toInt8() {
    return new Number();
  }

  /**
   *  转换为Byte类型
   *  @return Number
   */
  toByte() {
    return new Number();
  }

  /**
   *  转换为Short类型
   *  @return Number
   */
  toShort() {
    return new Number();
  }

  /**
   *  转换为Int16类型
   *  @return Number
   */
  toInt16() {
    return new Number();
  }

  /**
   *  转换为Int32类型
   *  @return Number
   */
  toInt32() {
    return new Number();
  }

  /**
   *  转换为Long类型
   *  @return Number
   */
  toLong() {
    return new Number();
  }

  /**
   *  转换为Int64类型
   *  @return Number
   */
  toInt64() {
    return new Number();
  }

  /**
   *  转换为Uint32类型
   *  @return Number
   */
  toUint16() {
    return new Number();
  }

  /**
   *  转换为Uint32类型
   *  @return Number
   */
  toUint32() {
    return new Number();
  }

  /**
   *  转换为Double类型
   *  @return Number
   */
  toDouble() {
    return new Number();
  }

  /**
   *  如果两数值均不为零，则返回1，否则返回0
   *  @param {Number} number Number对象 
   *  @return Number
   */
  and(number: Number | number) {
    return new Number();
  }

  /**
   *  如果任一输入值非零，则返回1
   *  @param {Number} number Number对象
   *  @return Number
   */
  or(number: Number | number) {
    return new Number();
  }

  /**
   * 两数值进行非运算，结果为真则返回1，否则返回0
   * @param {Number} number Number对象
   * @return Number
   */
  not(number: Number | number) {
    return new Number();
  }

  /**
   *  两数值进行异或运算，结果为真则返回1，否则返回0
   *  @param {Number} number Number对象
   *  @return Number
   */
  xor(number: Number | number) {
    return new Number();
  }

  /**
   *  两数值进行相等运算，结果为真则返回1，否则返回0
   *  @param {Number} number Number对象
   *  @return Number
   */
  eq(number: Number | number) {
    return new Number();
  }

  /**
   *  两数值进行不相等运算，结果为真则返回1，否则返回0
   *  @param {Number} number Number对象
   *  @return Number
   */
  neq(number: Number | number) {
    return new Number();
  }

  /**
   *  两数值进行小于运算，结果为真则返回1，否则返回0
   *  @param {Number} number Number对象
   *  @return Number
   */
  lt(number: Number | number) {
    return new Number();
  }

  /**
   *  两数值进行小于等于运算，结果为真则返回1，否则返回0
   *  @param {Number} number Number对象
   *  @return Number
   */
  lte(number: Number | number) {
    return new Number();
  }

  /**
   *  两数值进行大于运算，结果为真则返回1，否则返回0
   *  @param {Number} number Number对象
   *  @return Number
   */
  gt(number: Number | number) {
    return new Number();
  }

  /**
   *  两数值进行大于等于运算，结果为真则返回1，否则返回0
   *  @param {Number} number Number对象
   *  @return Number
   */
  gte(number: Number | number) {
    return new Number();
  }

  /**
   *  返回整型变量i转化成二进制表示时1的个数
   *  @param {Number} number Number对象
   *  @return Number
   */
  bitCount(number: Number | number) {
    return new Number();
  }

  /**
   *  计算两个整数的基础二进制表示的按位与
   *  @param {Number} number Number对象
   *  @return Number
   */
  bitwiseAnd(number: Number | number) {
    return new Number();
  }

  /**
   *  计算两个整数的基础二进制表示的按位非
   *  @param {Number} number Number对象
   *  @return Number
   */
  bitwiseNot(number: Number | number) {
    return new Number();
  }

  /**
   *  计算两个整数的基础二进制表示的按位异或
   *  @param {Number} number Number对象
   *  @return Number
   */
  bitwiseXor(number: Number | number) {
    return new Number();
  }

  /**
   *  计算两个整数的基础二进制表示的按位或
   *  @param {Number} number Number对象
   *  @return Number
   */
  bitwiseOr(number: Number | number) {
    return new Number();
  }

  /**
   *  计算两个数值的和
   *  @param {Number} number Number对象
   *  @return Number
   */
  add(number: Number | number) {
    return new Number();
  }

  /**
   *  计算第一个数除以第二个数的值
   *  @param {Number} number Number对象
   *  @return Number
   */
  divide(number: Number | number) {
    return new Number();
  }

  /**
   *  计算两个数值的欧几里德范数
   *  @param {Number} number Number对象
   *  @return Number
   */
  hypot(number: Number | number) {
    return new Number();
  }

  /**
   *  返回两个数值中的最大值
   *  @param {Number} number Number对象
   *  @return Number
   */
  max(number: Number | number) {
    return new Number();
  }

  /**
   *  返回两个数值中的最小值
   *  @param {Number} number Number对象
   *  @return Number
   */
  min(number: Number | number) {
    return new Number();
  }

  /**
   *  计算第一个数除以第二个数的余数
   *  @param {Number} number Number对象
   *  @return Number
   */
  mod(number: Number | number) {
    return new Number();
  }

  /**
   *  计算两个数值的乘积
   *  @param {Number} number Number对象
   *  @return Number
   */
  multiply(number: Number | number) {
    return new Number();
  }

  /**
   *  将第二个值作为第一个值的幂，返回计算结果
   *  @param {Number} number Number对象
   *  @return Number
   */
  pow(number: Number | number) {
    return new Number();
  }

  /**
   *  计算两个数值的差
   *  @param {Number} number Number对象
   *  @return Number
   */
  subtract(number: Number | number) {
    return new Number();
  }

  /**
   *  算术左移位运算
   *  @param {Number} number Number对象
   *  @return Number
   */
  left_shift(number: Number | number) {
    return new Number();
  }

  /**
   *  算术右移位运算
   *  @param {Number} number Number对象
   *  @return Number
   */
  right_shift(number: Number | number) {
    return new Number();
  }
  /**
   *  计算 digamma 值
   *  @return Number
   */
  digamma() {
    return new Number();
  }

  /**
   *  计算 gamma 值, 小于或等于0的值无效。
   *  @return Number
   */
  gamma() {
    return new Number();
  }

  /**
   *  计算 trigamma 值
   *  @return Number
   */
  trigamma() {
    return new Number();
  }

  /**
   *  计算 gammainc 值
   *  @param {Number} number Number对象
   *  @return Number
   */
  gammainc(number: Number | number) {
    return new Number();
  }

  /**
   *  取第一个值
   *  @param {Number} number Number对象
   *  @return Number
   */
  first(number: Number | number) {
    return new Number();
  }

  /**
   *  取第一个非零值
   *  @param {Number} number Number对象
   *  @return Number
   */
  firstNonZero(number: Number | number) {
    return new Number();
  }

  /**
   *  使用给定的格式把数字转为字符串
   *  @param {string} format 表示格式的字符串，默认为“s%”
   *  @return String
   */
  format(format: string = "s%") {
    return new String();
  }

  /**
   *  把目标值拉伸到特定区域（使用给定的范围缩放输入）
   *  @param {Number} min 范围最小值
   *  @param {Number} max 范围最大值
   *  @return Number
   */
  unitScale(min: Number | number, max: Number | number) {
    return new Number();
  }

  /**
   *  计算输入误差函数
   *  @return Number
   */
  erf() {
    return new Number();
  }

  /**
   *  计算输入反误差函数
   *  @return Number
   */
  erfInv() {
    return new Number();
  }

  /**
   *  计算输入的逆互补误差函数
   *  @return Number
   */
  erfcInv() {
    return new Number();
  }

  /**
   *  计算输入的互补误差函数
   *  @return Number
   */
  erfc() {
    return new Number();
  }

  /**
   * 将字符串转为数字
   * @param {String} input 待转换的字符串
   * @param {Number} [radix] 可选参数，一个整数，表示要转换的基数系统
   * @return Number
   * @tutorial gve.Number
   */
  static parse(input: string, radix?: number | Number) {
    return new Number();
  }

  /**
   *  将值限制在最大最小值范围内
   *  @param {Number} min 范围最小值
   *  @param {Number} max 范围最大值
   *  @return Number
   */
  clamp(min: Number | number, max: Number | number) {
    return new Number();
  }

  /**
   *  计算绝对值
   *  @return Number
   */
  abs() {
    return new Number();
  }

  /**
   *  表达式计算
   * @param {String} expression 要计算的数学表达式字符串
   * @param {Dictionary|object} vars 可以在表达式中使用的命名值的字典
   * @return Number
   * @tutorial gve.Number
   */
  static expression(expression: string, vars: Dictionary | object) {
    return new Number();
  }

  /**
   *  计算二维矢量[x, y]形成的角度
   *  @param {Number} right 待计算的数
   *  @return Number
   */
  atan2(right:number) {
    return new Number();
  }
  /**
   * 计算输入的Lanczos近似
   * @returns Number
   */
  lanczos(){
    return new Number();
  }
}