/*
* Copyright (C) 2015 Edward Raff
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
package jsat.distributions.discrete;
import jsat.distributions.Distribution;
import jsat.math.Function1D;
import jsat.math.rootfinding.Zeroin;
/**
* This abstract class defines the contract for a distribution over the integer
* values.
*
* The {@link #cdf(double) } method will behave by
* {@link Math#floor(double) rounding down} and then calling the integer {@link #cdf(int)
* } counterpart.
*
* @author Edward Raff
*/
abstract public class DiscreteDistribution extends Distribution
{
/**
* Computes the log of the Probability Mass Function. Note, that then the
* probability is zero, {@link Double#NEGATIVE_INFINITY} would be the true
* value. Instead, this method will always return the negative of
* {@link Double#MAX_VALUE}. This is to avoid propagating bad values through
* computation.
*
* @param x the value to get the log(PMF) of
* @return the value of log(PMF(x))
*/
public double logPmf(int x)
{
double pmf = pmf(x);
if (pmf <= 0)
return -Double.MAX_VALUE;
return Math.log(pmf);
}
abstract public double pmf(int x);
/**
* Computes the value of the Cumulative Density Function (CDF) at the given point.
* The CDF returns a value in the range [0, 1], indicating what portion of values
* occur at or below that point.
*
* @param x the value to get the CDF of
* @return the CDF(x)
*/
abstract public double cdf(int x);
@Override
public double cdf(double x)
{
return cdf((int)Math.floor(x));
}
@Override
public double invCdf(double p)
{
return invCdfRootFinding(p, 1e-6);
}
/**
* Helper method that computes the inverse CDF by performing root-finding on
* the CDF of the function. This provides a convenient default method for
* any invCdfRootFinding implementation, but may not be as fast or accurate
* as possible.
*
* @param p the probability value
* @param tol the search tolerance
* @return the value such that the CDF would return p
*/
protected double invCdfRootFinding(double p, double tol)
{
if (p < 0 || p > 1)
throw new ArithmeticException("Value of p must be in the range [0,1], not " + p);
//two special case checks, as they can cause a failure to get a positive and negative value on the ends, which means we can't do a search for the root
//Special case check, p < min value
if(min() >= Integer.MIN_VALUE)
if(p <= cdf(min()))
return min();
//special case check, p >= max value
if(max() < Integer.MAX_VALUE)
if(p > cdf(max()-1))
return max();
//stewpwise nature fo discrete can cause problems for search, so we will use a smoothed cdf to pass in
// double toRet= invCdf(p, );
//Lets use an interpolated version of the CDF so that our numerical methods will behave better
Function1D cdfInterpolated = (double x) ->
{
double query = x;
//if it happens to fall on an int we just compute the regular value
if(Math.rint(query) == query)
return cdf((int)query) - p;
//else, interpolate
double larger = query+1;
double diff = larger-query;
return cdf(query)*diff + cdf(larger)*(1-diff) - p;
};
double a = Double.isInfinite(min()) ? Integer.MIN_VALUE*.95 : min();
double b = Double.isInfinite(max()) ? Integer.MAX_VALUE*.95 : max();
double toRet = Zeroin.root(tol, a, b, cdfInterpolated);
return Math.round(toRet);
}
@Override
abstract public DiscreteDistribution clone();
}
Ads help maintain this website.