package scientific.stats.continuous

import std.math.*
import std.unittest.*
import std.unittest.testmacro.*

import scientific.numbers.*
import scientific.stats.random.*

/*
 * Log of Probability density function
 */
public func hypsecantLogPDF(x: Float64, loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    let y = (x - loc) / scale   

    let res = hypsecantPDF(x, loc: loc, scale: scale)

    if (res < 0.000001) {
        throw IllegalArgumentException("hypsecantLogPDF: return-value too small.")
    }

    return log(res)
}

/*
 * Probability density function
 */
public func hypsecantPDF(x: Float64, loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    let y = (x - loc) / scale

    return 1.0 / Float64.getPI() / cosh(y)
}


/*
 * Cumulative probability density function
 */
public func hypsecantCDF(x: Float64, loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    let y = (x - loc) / scale

    return 2.0 / Float64.getPI() * atan(exp(y))
}


/*
 * Cumulative probability density function
 */
public func hypsecantLogCDF(x: Float64, loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    let y = (x - loc) / scale

    let temp = hypsecantCDF(x, loc: loc, scale: scale)

    if (temp < 0.000001) {
        throw IllegalArgumentException("hypsecantLogCDF: return-value too small.")
    }

    return log(temp)
}


/*
 * PPF
 */
public func hypsecantPPF(q: Float64, loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    if (q <= 0.0 || q >= 1.0) {
        throw IllegalArgumentException("hypsecantPPF: quantile out of bound.")
    }

    let temp = tan(0.5 * Float64.getPI() * q)
    let res = log(temp)
    return res * scale + loc
}


/*
 * compute the mean
 */
public func hypsecantMean(loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    return loc
}


/*
 * compute the var
 */
public func hypsecantVar(loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    return  Float64.getPI() * Float64.getPI() / 4.0 * scale * scale
}

/*
 * compute the std
 */
public func hypsecantStd(loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    let temp = hypsecantVar(loc: loc, scale: scale)

    if (temp < 0.000001) {
        throw IllegalArgumentException("hypsecantStd: return-value too small.")
    }

    return sqrt(temp)
}

@Test
public class TestHypsecant {
    @TestCase
    func testHypsecant(): Unit {
        @Assert(approxEqual(hypsecantLogPDF(3.0, loc: 2.0, scale: 1.0), -1.5785107163324272, atol:1e-13))
        @Assert(approxEqual(hypsecantLogCDF(3.0, loc: 2.0, scale: 1.0), -0.254140292843152,  atol:1e-13))
        @Assert(approxEqual(hypsecantPPF(0.7, loc: 2.0, scale: 1.0),     2.6742754776268165, atol:1e-13))
    }
}