# commons-dev mailing list archives

##### Site index · List index
Message view
Top
From Ted Dunning <ted.dunn...@gmail.com>
Subject Re: [Math] Issue 348
Date Sat, 06 Mar 2010 00:33:43 GMT
```Here is one.  The goal is to provide an over-dispersed exponential
distribution which is defined as an exponential distribution with a prior
distribution on the lambda parameter.

/**
* Sample from an exponential distribution whose parameter is distributed
according
* to a Gamma distribution.
*/
public class UncertainExponentialDistribution extends
ExponentialDistribution {
private Gamma prior;

public UncertainExponentialDistribution(double alpha, double beta) {
prior = new Gamma(alpha, beta);
}

public double getLambda() {
return prior.next();
}
}

Doing this with an immutable super class is a royal pain in the ass.  Doing
this with setters on lambda isn't sooo bad, but it really obscures the real
point which is that the over-dispersed exponential distribution is *exactly*
an exponential distribution but lambda varies.  The implementation above
says exactly that.

So what about the layer below?  The exponential can be defined as a
specialized Gamma which benefits from the same sort of idiom (yes I know
that this distribution can be implemented as -lambda * log(1-rand()), but we
are talking principles here, not specifics).

public class ExponentialDistribution extends AbstractDistribution {
private double lambda;

private Gamma wrapped;

public ExponentialDistribution() {
}

public ExponentialDistribution(double lambda) {
this.lambda = lambda;
wrapped = new Gamma(1, 1 / lambda) {
@Override
public double getAlpha() {
return 1;
}

@Override
public double getBeta() {
return 1 / getLambda();
}
};
}

public double next() {
return wrapped.next();
}

/**
* Default implementation of this getter just returns the value we
know.  Sub-classes
* might over-ride this for special effects.
* @return
*/
public double getLambda() {
return lambda;
}
}

Again, we have clarity of expression.  The phrase "gamma distribution with
alpha = 1 and beta = 1/lambda" is just what is in the code here.  You
*could* do this with setters, but at considerable loss of clarity and no
gain in efficiency.

On Fri, Mar 5, 2010 at 3:51 PM, Gilles Sadowski <
gilles@harfang.homelinux.org> wrote:

> Sorry, I don't follow you. Could you give a code example of these
> one-liners?
>

--
Ted Dunning, CTO
DeepDyve

```
Mime
• Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message