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 fiskLogPDF(x: Float64, c: Float64, loc!: Float64 = 0.0, scale!: Float64 = 1.0): Float64 {
    let y = (x - loc) / scale

    if (y < 0.0) {
        throw IllegalArgumentException("fiskLogPDF: input value x out of bound.")
    }

    if (c <= 0.0) {
        throw IllegalArgumentException("fiskLogPDF: shape parameter out of bound.")
    }

    return burrLogPDF(x, c, 1.0, loc:loc, scale: scale)
}

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

    if (y < 0.0) {
        throw IllegalArgumentException("fiskPDF: input value x out of bound.")
    }

    if (c <= 0.0) {
        throw IllegalArgumentException("fiskPDF: shape parameter out of bound.")
    }

    return burrPDF(x, c, 1.0, loc: loc, scale: scale)
}

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

    if (y < 0.0) {
        throw IllegalArgumentException("fiskCDF: input value x out of bound.")
    }

    if (c <= 0.0) {
        throw IllegalArgumentException("fiskCDF: shape parameter out of bound.")
    }

    return burrCDF(x, c, 1.0, loc: loc, scale: scale)
}

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

    if (y < 0.0) {
        throw IllegalArgumentException("fiskLogCDF: input value x out of bound.")
    }

    if (c <= 0.0) {
        throw IllegalArgumentException("fiskLogCDF: shape parameter out of bound.")
    }

    return burrLogCDF(x, c, 1.0, loc: loc, scale: scale)
}


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

    if (c <= 0.0) {
        throw IllegalArgumentException("fiskPPF: shape parameter out of bound.")
    }

    return burrPPF(q, c, 1.0, loc: loc, scale: scale)
}

@Test
public class TestFisk {
    @TestCase
    func testFisk(): Unit {
        @Assert(approxEqual(fiskLogPDF(2.0, 2.0, loc: 1.0, scale: 2.0), -1.1394342831883648, atol:1e-13))
        @Assert(approxEqual(fiskLogCDF(2.0, 2.0, loc: 1.0, scale: 2.0), -1.6094379124341003, atol:1e-13)) 
        @Assert(approxEqual(fiskPPF(0.2, 2.0, loc: 1.0, scale: 2.0),     2.0,                atol:1e-13)) 
    }
}