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

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

    if (y < a || y > c) {
        throw IllegalArgumentException("loguniformLogPDF: input value out of bound.")
    }

    let temp = loguniformPDF(x, a, c, loc: loc, scale: scale)
    if (temp < 0.000001) {
        throw IllegalArgumentException("loguniformLogPDF: return-value too small.")
    }
    return log(temp)
}

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

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

    if (y < a || y > c) {
        throw IllegalArgumentException("loguniformPDF: input value out of bound.")
    }

    let res = 1.0 / (y * log(c / a))
    return res / scale
}

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

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

    if (y < a || y > c) {
        throw IllegalArgumentException("loguniformCDF: input value out of bound.")
    }

    let res = (log(y) - log(a)) / log(c / a)
    return res
}

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

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

    if (y < a || y > c) {
        throw IllegalArgumentException("loguniformLogCDF: input value out of bound.")
    }

    let temp = loguniformCDF(x, a, c, loc: loc, scale: scale)
    if (temp < 0.000001) {
        throw IllegalArgumentException("loguniformLogCDF: return-value too small.")
    }
    return log(temp)
}

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

    let res = a * pow(c / a, q)
    return res * scale + loc
}

@Test
public class TestLogUniform {
    @TestCase
    func testLoguniform(): Unit {
        @Assert(approxEqual(loguniformLogPDF(2.0, 0.1, 1.0, loc: 1.0, scale: 2.0), -0.834032445247956,  atol:1e-13))
        @Assert(approxEqual(loguniformLogCDF(2.0, 0.1, 1.0, loc: 1.0, scale: 2.0), -0.3581474499208454, atol:1e-13))
        @Assert(approxEqual(loguniformPPF(0.2, 0.1, 1.0, loc: 1.0, scale: 2.0),    1.3169786384922229,  atol:1e-6))
    }
}