text: import assert from 'assert'
  import math from '../../../src/bundleAny'
  import approx from '../../../tools/approx'
  const pi = math.pi
  const asech = math.asech
  const sech = math.sech
  const complex = math.complex
  const matrix = math.matrix
  const unit = math.unit
  const bigmath = math.create({ number: 'BigNumber', precision: 20 })
  const biggermath = math.create({ precision: 22 })
  const predmath = math.create({ predictable: true })
  const asechBig = bigmath.asech
  const Big = bigmath.bignumber
  
  describe('asech', function () {
    it('should return the hyperbolic arcsec of a boolean', function () {
      assert.strictEqual(asech(true), 0)
      assert.strictEqual(asech(false), Infinity)
    })
  
    it('should return the hyperbolic arcsec of a number', function () {
      approx.deepEqual(asech(-0.5), complex(1.3169578969, pi))
      approx.deepEqual(asech(2), complex(0, pi / 3))
      // assert.ok(isNaN(asech(-0.5)))
      // assert.ok(isNaN(asech(2)))
  
      assert.strictEqual(asech(0), Infinity)
      approx.equal(asech(0.25), 2.0634370688955605467272811726201)
      approx.equal(asech(0.5), 1.31695789692481670862504634730797)
      approx.equal(asech(0.75), 0.7953654612239056305278909331478)
      assert.strictEqual(asech(1), 0)
    })
  
    it('should return the hyperbolic arcsec of a number when predictable:true', function () {
      assert.strictEqual(typeof predmath.asech(2), 'number')
      assert(isNaN(predmath.asech(2)))
    })
  
    it('should return the hyperbolic arcsec of a bignumber', function () {
      const arg1 = Big(0)
      const arg2 = Big(0.25)
      assert.deepStrictEqual(asechBig(arg1).toString(), 'Infinity')
      assert.deepStrictEqual(asechBig(arg2), Big('2.0634370688955605467'))
      assert.deepStrictEqual(asechBig(Big(0.5)), Big('1.3169578969248167086'))
      assert.deepStrictEqual(asechBig(Big(0.75)), Big('0.79536546122390563049'))
      assert.deepStrictEqual(asechBig(Big(1)), Big(0))
  
      // Make sure arg was not changed
      assert.deepStrictEqual(arg1, Big(0))
      assert.deepStrictEqual(arg2, Big(0.25))
  
      /* out of range */
      assert.ok(asech(Big(-1)).isNaN())
      assert.ok(asech(Big(2)).isNaN())
    })
  
    it('should be the inverse function of hyperbolic sec', function () {
      approx.equal(asech(sech(-1)), 1)
      approx.equal(asech(sech(0)), 0)
      approx.equal(asech(sech(0.1)), 0.1)
      approx.equal(asech(sech(0.5)), 0.5)
      approx.equal(asech(sech(2)), 2)
    })
  
    it('should be the inverse function of bignumber sech', function () {
      assert.deepStrictEqual(asechBig(bigmath.sech(Big(-1))), Big(1))
      assert.deepStrictEqual(asechBig(bigmath.sech(Big(0))), Big(0))
      assert.deepStrictEqual(asechBig(bigmath.sech(Big(0.5))), Big('0.49999999999999999995'))
      assert.deepStrictEqual(asechBig(bigmath.sech(Big(2))), Big(2))
  
      /* Pass in more digits to pi. */
      assert.deepStrictEqual(asechBig(biggermath.sech(Big(0.1))), Big('0.10000000000000000012'))
    })
  
    it('should return the arcsech of a complex number', function () {
      approx.deepEqual(asech(complex('2+3i')), complex(0.23133469857397, -1.420410722467035))
      approx.deepEqual(asech(complex('2-3i')), complex(0.23133469857397, 1.420410722467035))
      approx.deepEqual(asech(complex('-2+3i')), complex(0.23133469857397, -1.72118193112275858))
      approx.deepEqual(asech(complex('-2-3i')), complex(0.23133469857397, 1.72118193112275858))
      approx.deepEqual(asech(complex('1+i')), complex(0.5306375309525178, -1.11851787964370594))
      approx.deepEqual(asech(complex('i')), complex(0.881373587019543, -1.570796326794897))
      approx.deepEqual(asech(complex('2')), complex(0, pi / 3))
      assert.deepStrictEqual(asech(complex('1')), complex(-0, 0))
      approx.deepEqual(asech(complex('0.5')), complex(1.3169578969248, 0))
      assert.deepStrictEqual(asech(complex('0')), complex(Infinity, Infinity))
      approx.deepEqual(asech(complex('-0.5')), complex(1.3169578969248, pi))
      approx.deepEqual(asech(complex('-1')), complex(0, pi))
    })
  
    it('should throw an error if called with a unit', function () {
      assert.throws(function () { asech(unit('45deg')) })
      assert.throws(function () { asech(unit('5 celsius')) })
    })
  
    it('should throw an error if called with a string', function () {
      assert.throws(function () { asech('string') })
    })
  
    it('should calculate the arcsec element-wise for arrays and matrices', function () {
      const asech01 = [Infinity, 0]
      assert.deepStrictEqual(asech([0, 1]), asech01)
      assert.deepStrictEqual(asech(matrix([0, 1])), matrix(asech01))
    })
  
    it('should throw an error in case of invalid number of arguments', function () {
      assert.throws(function () { asech() }, /TypeError: Too few arguments/)
      assert.throws(function () { asech(1, 2) }, /TypeError: Too many arguments/)
    })
  
    it('should LaTeX asech', function () {
      const expression = math.parse('asech(1)')
      assert.strictEqual(expression.toTex(), '\\mathrm{sech}^{-1}\\left(1\\right)')
    })
  })
  