public double exactSolution(double asset, double time) {
setup(asset, time);
return -asset * Math.exp(-dividend * (maturityTime - time)) * SpecialFunctions.normalCdf(-d[0])
+ strike
* Math.exp(-interestRate * (maturityTime - time))
* SpecialFunctions.normalCdf(-d[1]);
}
private double modelLevyAsian(double S, double K, double r, double div, double sig, double T) {
double valueLevy = 0.0;
double se = 0.0;
double m = 0.0;
double d = 0.0;
double sv = 0.0;
double xStar = 0.0;
double d1, d2 = 0.0;
double b = r - div; // cost of carry rate
double t2 = T; // remaining time to maturity
double sa = S; // Arithmetic Average price
se = S / (T * b) * (Math.exp((b - r) * t2) - Math.exp(-r * t2));
m =
2
* Math.pow(S, 2)
/ (b + Math.pow(sig, 2))
* ((Math.exp((2 * b + Math.pow(sig, 2)) * t2) - 1) / (2 * b + Math.pow(sig, 2))
- (Math.exp(b * t2) - 1) / b);
d = m / Math.pow(T, 2);
sv = Math.log(d) - 2 * (r * t2 + Math.log(se));
xStar = K - ((T - t2) / T) * sa;
d1 = 1 / Math.sqrt(sv) * (Math.log(d) / 2 - Math.log(xStar));
d2 = d1 - Math.sqrt(sv);
valueLevy = se * CND(d1) - xStar * Math.exp(-r * t2) * CND(d2);
return valueLevy;
}
// loss = add( w[i] * log(1+exp(-y[i]* weightT * x[i])) ) + 0.5 * lbfgs_l2_c * ||weight||2
@Override
public void map(AvroKey<lbfgsdata> key, NullWritable nullvalue, Context context) {
lbfgsdata data = key.datum();
float w = data.getWeight();
float offset = data.getOffset();
int y = data.getResponse();
List<entry> l = data.getFeatures();
double decision_value = 0.0;
for (entry e : l) {
decision_value += e.getValue() * weight[e.getIndex()];
}
decision_value += offset;
double loss_temp;
loss_temp = y * decision_value;
if (loss_temp > 0) {
loss_temp = Math.log(1 + Math.exp(-loss_temp));
} else {
loss_temp = ((-loss_temp) + Math.log(1 + Math.exp(loss_temp)));
}
loss += w * loss_temp;
double gradient_temp = (1 / (1 + Math.exp(-y * decision_value)) - 1) * y * w;
for (entry e : l) {
gradient[e.getIndex()] += gradient_temp * e.getValue();
}
}
/**
* Compute theta price of cash-or-nothing option
*
* @param spot The spot
* @param strike The strike
* @param timeToExpiry The time to expiry
* @param lognormalVol The log-normal volatility
* @param interestRate The interest rate
* @param costOfCarry The cost-of-carry
* @param isCall True for calls, false for puts
* @return The option price
*/
public static double theta(
final double spot,
final double strike,
final double timeToExpiry,
final double lognormalVol,
final double interestRate,
final double costOfCarry,
final boolean isCall) {
ArgumentChecker.isTrue(spot > 0.0, "negative/NaN spot; have {}", spot);
ArgumentChecker.isTrue(strike > 0.0, "negative/NaN strike; have {}", strike);
ArgumentChecker.isTrue(timeToExpiry > 0.0, "negative/NaN timeToExpiry; have {}", timeToExpiry);
ArgumentChecker.isTrue(lognormalVol > 0.0, "negative/NaN lognormalVol; have {}", lognormalVol);
ArgumentChecker.isFalse(Double.isNaN(interestRate), "interestRate is NaN");
ArgumentChecker.isFalse(Double.isNaN(costOfCarry), "costOfCarry is NaN");
final double d =
(Math.log(spot / strike) + (costOfCarry - 0.5 * lognormalVol * lognormalVol) * timeToExpiry)
/ lognormalVol
/ Math.sqrt(timeToExpiry);
final double sign = isCall ? 1. : -1.;
final double div =
0.5
* (-Math.log(spot / strike) / Math.pow(timeToExpiry, 1.5)
+ (costOfCarry - 0.5 * lognormalVol * lognormalVol) / Math.pow(timeToExpiry, 0.5))
/ lognormalVol;
return interestRate * Math.exp(-interestRate * timeToExpiry) * NORMAL.getCDF(sign * d)
- sign * Math.exp(-interestRate * timeToExpiry) * NORMAL.getPDF(d) * div;
}
private void getnegphase() {
/*
* It does the negative phase of unsupervised RBM training algorithm
*
* For details, please refer to Dr. Hinton's paper:
* Reducing the dimensionality of data with neural networks. Science, Vol. 313. no. 5786, pp. 504 - 507, 28 July 2006.
*/
// start calculate the negative phase
// calculate the curved value of v1,h1
// find the vector of v1
Matrix negdata = poshidstates.times(vishid.transpose());
// (1 * numhid) * (numhid * numdims) = (1 * numdims)
negdata.plusEquals(visbiases);
// poshidstates*vishid' + visbiases
double[][] tmp1 = negdata.getArray();
int i1 = 0;
while (i1 < numdims) {
tmp1[0][i1] = 1 / (1 + Math.exp(-tmp1[0][i1]));
i1++;
}
// find the vector of h1
neghidprobs = negdata.times(vishid);
// (1 * numdims) * (numdims * numhid) = (1 * numhid)
neghidprobs.plusEquals(hidbiases);
double[][] tmp2 = neghidprobs.getArray();
int i2 = 0;
while (i2 < numhid) {
tmp2[0][i2] = 1 / (1 + Math.exp(-tmp2[0][i2]));
i2++;
}
negprods = negdata.transpose().times(neghidprobs);
// (numdims * 1) *(1 * numhid) = (numdims * numhid)
}
public Double eval(Double gamma) {
double c = 1.0 / (double) Math.sqrt(variance);
double sum = 0.0;
for (Integer i : transcripts.get(gammat)) {
double pi = 0.0;
for (int t = 0; t < fiveprime.length; t++) {
if (transcripts.get(t).contains(i)) {
double gammai = gammat == t ? gamma : gammas[t][gammak];
double dit = delta(i, t);
double pit = gammai * Math.exp(-lambda * dit);
pi += pit;
}
}
double zi = Math.log(pi);
double err = data.values(i)[channels[gammak]] - zi;
double ratio = (Math.exp(-lambda * delta(i, gammat))) / pi;
double termi = (err * ratio);
sum += termi;
}
return c * sum;
}
public final double lgrad(double u, double a, Loss loss) {
assert loss.isForNumeric() : "Loss function " + loss + " not applicable to numerics";
switch (loss) {
case Quadratic:
return 2 * (u - a);
case Absolute:
return Math.signum(u - a);
case Huber:
return Math.abs(u - a) <= 1 ? u - a : Math.signum(u - a);
case Poisson:
assert a >= 0 : "Poisson loss L(u,a) requires variable a >= 0";
return Math.exp(u) - a;
case Hinge:
// return a*u <= 1 ? -a : 0;
return a == 0
? (-u <= 1 ? 1 : 0)
: (u <= 1 ? -1 : 0); // Booleans are coded as {0,1} instead of {-1,1}
case Logistic:
// return -a/(1+Math.exp(a*u));
return a == 0
? 1 / (1 + Math.exp(-u))
: -1 / (1 + Math.exp(u)); // Booleans are coded as {0,1} instead of {-1,1}
case Periodic:
return ((2 * Math.PI) / _period) * Math.sin((a - u) * (2 * Math.PI) / _period);
default:
throw new RuntimeException("Unknown loss function " + loss);
}
}
public void forwardIBD() {
int numNodes = treeModel.getNodeCount();
int stateCount = substitutionModel.getStateCount();
getDiagonalRates(diag);
for (int nodeId = 0; nodeId < numNodes; ++nodeId) {
NodeRef node = treeModel.getNode(nodeId);
NodeRef parent = treeModel.getParent(node);
if (parent == null) { // handle the root
} else if (treeModel.isExternal(node)) { // Handle the tip
double branchTime =
branchRateModel.getBranchRate(treeModel, node)
* (treeModel.getNodeHeight(parent) - treeModel.getNodeHeight(node));
for (int state = 0; state < stateCount; ++state) {
ibdForward[nodeId][state] = Math.exp(-diag[state] * branchTime);
}
} else { // Handle internal node
double branchTime =
branchRateModel.getBranchRate(treeModel, node)
* (treeModel.getNodeHeight(parent) - treeModel.getNodeHeight(node));
int childCount = treeModel.getChildCount(node);
for (int state = 0; state < stateCount; ++state) {
ibdForward[nodeId][state] = 0;
for (int child = 0; child < childCount; ++child) {
int childNodeId = treeModel.getChild(node, child).getNumber();
ibdForward[nodeId][state] += ibdForward[childNodeId][state];
}
ibdForward[nodeId][state] *= Math.exp(-diag[state] * branchTime);
}
}
}
}
public final double loss(double u, double a, Loss loss) {
assert loss.isForNumeric() : "Loss function " + loss + " not applicable to numerics";
switch (loss) {
case Quadratic:
return (u - a) * (u - a);
case Absolute:
return Math.abs(u - a);
case Huber:
return Math.abs(u - a) <= 1 ? 0.5 * (u - a) * (u - a) : Math.abs(u - a) - 0.5;
case Poisson:
assert a >= 0 : "Poisson loss L(u,a) requires variable a >= 0";
return Math.exp(u)
+ (a == 0 ? 0 : -a * u + a * Math.log(a) - a); // Since \lim_{a->0} a*log(a) = 0
case Hinge:
// return Math.max(1-a*u,0);
return Math.max(1 - (a == 0 ? -u : u), 0); // Booleans are coded {0,1} instead of {-1,1}
case Logistic:
// return Math.log(1 + Math.exp(-a * u));
return Math.log(
1 + Math.exp(a == 0 ? u : -u)); // Booleans are coded {0,1} instead of {-1,1}
case Periodic:
return 1 - Math.cos((a - u) * (2 * Math.PI) / _period);
default:
throw new RuntimeException("Unknown loss function " + loss);
}
}
public void printChildTopWords(int k, String childBetaFile) {
try {
System.out.println("child beta file");
PrintWriter childBetaOut = new PrintWriter(new File(childBetaFile));
for (int i = 0; i < m_childTopicTermProb.length; i++) {
MyPriorityQueue<_RankItem> fVector = new MyPriorityQueue<_RankItem>(k);
for (int j = 0; j < vocabulary_size; j++)
fVector.add(new _RankItem(m_corpus.getFeature(j), m_childTopicTermProb[i][j]));
childBetaOut.format("Topic %d(%.3f):\t", i, m_childSstat[i]);
System.out.format("Topic %d(%.3f):\t", i, m_childSstat[i]);
for (_RankItem it : fVector) {
childBetaOut.format(
"%s(%.3f)\t", it.m_name, m_logSpace ? Math.exp(it.m_value) : it.m_value);
System.out.format(
"%s(%.3f)\t", it.m_name, m_logSpace ? Math.exp(it.m_value) : it.m_value);
}
childBetaOut.println();
System.out.println();
}
childBetaOut.flush();
childBetaOut.close();
} catch (Exception ex) {
System.err.print("File Not Found");
}
}
public void printTopWords(int k, String betaFile) {
Arrays.fill(m_parentSstat, 0);
Arrays.fill(m_childSstat, 0);
System.out.println("print top words");
for (_Doc d : m_trainSet) {
if (d instanceof _ParentDoc2) {
// print out topic assignment of parent
printParentTopicAssignment((_ParentDoc2) d);
for (int i = 0; i < number_of_topics; i++)
m_parentSstat[i] += m_logSpace ? Math.exp(d.m_topics[i]) : d.m_topics[i];
} else if (d instanceof _ChildDoc2) {
// print out topic assignment of child
printChildTopicAssignment((_ChildDoc2) d);
for (int i = 0; i < number_of_topics; i++)
m_childSstat[i] += m_logSpace ? Math.exp(d.m_topics[i]) : d.m_topics[i];
}
}
Utils.L1Normalization(m_parentSstat);
Utils.L1Normalization(m_childSstat);
String parentBetaFile = betaFile.replace(".txt", "parent.txt");
String childBetaFile = betaFile.replace(".txt", "child.txt");
printParentTopWords(k, parentBetaFile);
printChildTopWords(k, childBetaFile);
String parentParameterFile = parentBetaFile.replace("beta", "parameter");
String childParameterFile = childBetaFile.replace("beta", "parameter");
printParameter(parentParameterFile, childParameterFile);
}
@Override
public PerformanceVector evaluateIndividual(Individual individual) {
double[] beta = individual.getValues();
double fitness = 0.0d;
for (Example example : exampleSet) {
double eta = 0.0d;
int i = 0;
for (Attribute attribute : example.getAttributes()) {
double value = example.getValue(attribute);
eta += beta[i] * value;
i++;
}
if (addIntercept) {
eta += beta[beta.length - 1];
}
double pi = Math.exp(eta) / (1 + Math.exp(eta));
double classValue = example.getValue(label);
double currentFitness = classValue * Math.log(pi) + (1 - classValue) * Math.log(1 - pi);
double weightValue = 1.0d;
if (weight != null) weightValue = example.getValue(weight);
fitness += weightValue * currentFitness;
}
PerformanceVector performanceVector = new PerformanceVector();
performanceVector.addCriterion(
new EstimatedPerformance("log_reg_fitness", fitness, exampleSet.size(), false));
return performanceVector;
}
private static List<Queue<Pair<String, Double>>> topWordsForTopics(
String dir, Configuration job, List<String> wordList, int numWordsToPrint) {
List<Queue<Pair<String, Double>>> queues = Lists.newArrayList();
Map<Integer, Double> expSums = Maps.newHashMap();
for (Pair<IntPairWritable, DoubleWritable> record :
new SequenceFileDirIterable<IntPairWritable, DoubleWritable>(
new Path(dir, "part-*"), PathType.GLOB, null, null, true, job)) {
IntPairWritable key = record.getFirst();
int topic = key.getFirst();
int word = key.getSecond();
ensureQueueSize(queues, topic);
if (word >= 0 && topic >= 0) {
double score = record.getSecond().get();
if (expSums.get(topic) == null) {
expSums.put(topic, 0.0);
}
expSums.put(topic, expSums.get(topic) + Math.exp(score));
String realWord = wordList.get(word);
maybeEnqueue(queues.get(topic), realWord, score, numWordsToPrint);
}
}
for (int i = 0; i < queues.size(); i++) {
Queue<Pair<String, Double>> queue = queues.get(i);
Queue<Pair<String, Double>> newQueue = new PriorityQueue<Pair<String, Double>>(queue.size());
double norm = expSums.get(i);
for (Pair<String, Double> pair : queue) {
newQueue.add(new Pair<String, Double>(pair.getFirst(), Math.exp(pair.getSecond()) / norm));
}
queues.set(i, newQueue);
}
return queues;
}
public Complex tanh() {
double scalar;
double temp1Re, temp1Im;
double temp2Re, temp2Im;
Complex sinRes, cosRes;
// tanh(z) = sinh(z) / cosh(z)
scalar = Math.exp(re);
temp1Re = scalar * Math.cos(im);
temp1Im = scalar * Math.sin(im);
scalar = Math.exp(-re);
temp2Re = scalar * Math.cos(-im);
temp2Im = scalar * Math.sin(-im);
temp1Re -= temp2Re;
temp1Im -= temp2Im;
sinRes = new Complex(0.5 * temp1Re, 0.5 * temp1Im);
scalar = Math.exp(re);
temp1Re = scalar * Math.cos(im);
temp1Im = scalar * Math.sin(im);
scalar = Math.exp(-re);
temp2Re = scalar * Math.cos(-im);
temp2Im = scalar * Math.sin(-im);
temp1Re += temp2Re;
temp1Im += temp2Im;
cosRes = new Complex(0.5 * temp1Re, 0.5 * temp1Im);
return sinRes.div(cosRes);
}
private void validateMedian(double rake, double[][] table) {
String[] columnDescr = TABLE_HEADER_MEDIAN[0].trim().split("\\s+");
// check for SA
for (int i = 3; i < columnDescr.length - 1; i++) {
for (int j = 0; j < table.length; j++) {
int iper = i - 2;
double mag = table[j][0];
double rJB = table[j][1];
double expectedMedian = table[j][i];
double computedMedian = Math.exp(toro2002SHARE.getMean(iper, mag, rJB, rake));
computedMedian =
computedMedian
/ (AdjustFactorsSHARE.AFrock_TORO2002[iper]
* toro2002SHARE.computeStyleOfFaultingTerm(iper, rake)[2]);
assertEquals(expectedMedian, computedMedian, TOLERANCE);
}
}
// check for PGA
for (int j = 0; j < table.length; j++) {
double mag = table[j][0];
double rJB = table[j][1];
double expectedMedian = table[j][columnDescr.length - 1];
double computedMedian = Math.exp(toro2002SHARE.getMean(0, mag, rJB, rake));
computedMedian =
computedMedian
/ (AdjustFactorsSHARE.AFrock_TORO2002[0]
* toro2002SHARE.computeStyleOfFaultingTerm(0, rake)[2]);
assertEquals(expectedMedian, computedMedian, TOLERANCE);
}
}
/** Returns the sine of this complex number. */
public Complex sin() {
double izRe, izIm;
double temp1Re, temp1Im;
double temp2Re, temp2Im;
double scalar;
// sin(z) = ( exp(i*z) - exp(-i*z) ) / (2*i)
izRe = -im;
izIm = re;
// first exp
scalar = Math.exp(izRe);
temp1Re = scalar * Math.cos(izIm);
temp1Im = scalar * Math.sin(izIm);
// second exp
scalar = Math.exp(-izRe);
temp2Re = scalar * Math.cos(-izIm);
temp2Im = scalar * Math.sin(-izIm);
temp1Re -= temp2Re;
temp1Im -= temp2Im;
return new Complex(0.5 * temp1Im, -0.5 * temp1Re);
}
/** Returns the cosine of this complex number. */
public Complex cos() {
double izRe, izIm;
double temp1Re, temp1Im;
double temp2Re, temp2Im;
double scalar;
// cos(z) = ( exp(i*z) + exp(-i*z) ) / 2
izRe = -im;
izIm = re;
// first exp
scalar = Math.exp(izRe);
temp1Re = scalar * Math.cos(izIm);
temp1Im = scalar * Math.sin(izIm);
// second exp
scalar = Math.exp(-izRe);
temp2Re = scalar * Math.cos(-izIm);
temp2Im = scalar * Math.sin(-izIm);
temp1Re += temp2Re;
temp1Im += temp2Im;
return new Complex(0.5 * temp1Re, 0.5 * temp1Im);
}
/**
* Return the probability density for a particular point.
*
* @param x The point at which the density should be computed.
* @return The pdf at point x.
*/
public double density(Double x) {
if (x < 0) return 0;
return Math.pow(x / getBeta(), getAlpha() - 1)
/ getBeta()
* Math.exp(-x / getBeta())
/ Math.exp(Gamma.logGamma(getAlpha()));
}
private ArrayList<Double> forwardProp(Double[] input) {
for (int i = 0; i < hiddenLNo; i++) {
for (int j = 0; j < inputSize + 1; j++) {
if (j == inputSize) {
hiddenNodes.set(i, hiddenNodes.get(i) + w1[j][i] * bias);
} else {
hiddenNodes.set(i, hiddenNodes.get(i) + w1[j][i] * input[j]);
}
}
double temp = (1.0 / (1.0 + Math.exp(-hiddenNodes.get(i))));
hiddenNodes.set(i, temp);
}
for (int i = 0; i < outputLNo; i++) {
for (int j = 0; j < hiddenLNo + 1; j++) {
if (j == hiddenNodes.size()) {
outputNodes.set(i, outputNodes.get(i) + w2[j][i] * bias);
} else {
outputNodes.set(i, outputNodes.get(i) + w2[j][i] * hiddenNodes.get(j));
}
}
// double temp1 = (1.0 / (1.0 + Math.exp(-outputNodes.get(i))));
outputNodes.set(i, (1.0 / (1.0 + Math.exp(-outputNodes.get(i)))));
}
return outputNodes;
}
@Test
public void meanShift() {
int w = 32;
CirculantTracker<ImageFloat32> alg =
new CirculantTracker<ImageFloat32>(1f / 16, 0.2, 1e-2, 0.075, 1.0, w, 255, interp);
int peakX = 13;
int peakY = 17;
alg.getResponse().reshape(w, w);
for (int i = 0; i < w; i++) {
double b = Math.exp(-(i - peakY) * (i - peakY) / 3.0);
for (int j = 0; j < w; j++) {
double a = Math.exp(-(j - peakX) * (j - peakX) / 3.0);
alg.getResponse().set(j, i, a * b);
}
}
alg.subpixelPeak(peakX - 2, peakY + 1);
assertEquals(2, alg.offX, 0.3);
assertEquals(-1, alg.offY, 0.3);
}
public double protectionLeg(IsdaCompliantCreditCurve creditCurve) {
double ht0 = creditCurve.getRT(_proLegIntPoints[0]);
double rt0 = _proYieldCurveRT[0];
double b0 = _proDF[0] * Math.exp(-ht0);
double pv = 0.0;
for (int i = 1; i < _nProPoints; ++i) {
double ht1 = creditCurve.getRT(_proLegIntPoints[i]);
double rt1 = _proYieldCurveRT[i];
double b1 = _proDF[i] * Math.exp(-ht1);
double dht = ht1 - ht0;
double drt = rt1 - rt0;
double dhrt = dht + drt;
// this is equivalent to the ISDA code without explicitly calculating the time step - it
// also handles the limit
double dPV;
if (Math.abs(dhrt) < 1e-5) {
dPV = dht * b0 * epsilon(-dhrt);
} else {
dPV = (b0 - b1) * dht / dhrt;
}
pv += dPV;
ht0 = ht1;
rt0 = rt1;
b0 = b1;
}
pv *= _lgdDF; // multiply by LGD and adjust to valuation date
return pv;
}
/**
* Perform the mutation strength strategy vector mutation for Evolution Strategies (Chapter 30) as
* specified in Algorithm 30.8.
*
* @param g the existing genotype in the search space from which a slightly modified copy should
* be created
* @param r the random number generator
* @return a new genotype
*/
@Override
public final double[] mutate(final double[] g, final Random r) {
final double[] gnew;
final double t0, t, c, nu;
int i;
double x;
i = g.length;
c = 1d;
// set tau0 according to Equation 30.12
t0 = (c / Math.sqrt(2 * i));
// set tau according to Equation 30.13
t = (c / Math.sqrt(2 * Math.sqrt(i)));
nu = Math.exp(t0 * r.nextGaussian());
gnew = g.clone();
// set each gene Definition D4.3 of gnew to ...
for (; (--i) >= 0; ) {
do {
x = gnew[i] * nu * Math.exp(t * r.nextGaussian());
} while ((x < this.min) || (x > this.max));
gnew[i] = x;
}
return gnew;
}
public synchronized double nextGamma(double alpha, double beta) {
double gamma = 0;
if (alpha <= 0 || beta <= 0) {
throw new IllegalArgumentException("alpha and beta must be strictly positive.");
}
if (alpha < 1) {
double b, p;
boolean flag = false;
b = 1 + alpha * Math.exp(-1);
while (!flag) {
p = b * random.nextDouble();
if (p > 1) {
gamma = -Math.log((b - p) / alpha);
if (random.nextDouble() <= Math.pow(gamma, alpha - 1)) flag = true;
} else {
gamma = Math.pow(p, 1 / alpha);
if (random.nextDouble() <= Math.exp(-gamma)) flag = true;
}
}
} else if (alpha == 1) {
gamma = -Math.log(random.nextDouble());
} else {
double y = -Math.log(random.nextDouble());
while (random.nextDouble() > Math.pow(y * Math.exp(1 - y), alpha - 1))
y = -Math.log(random.nextDouble());
gamma = alpha * y;
}
return beta * gamma;
}
/**
* Calculate fine fuel moisture: moisture of litter measured in %.
*
* @param dryBulbTemperature
* @param wetBulbTemperature
* @param herbstate
* @return double
*/
private double calculateFineFuelMoisture(
double dryBulbTemperature, double wetBulbTemperature, HerbState herbstate) {
double deltaT = dryBulbTemperature - wetBulbTemperature;
double ffm = 0.; // fine fuel moisture
if (deltaT <= diffTemperature[0]) {
ffm = constantsFineFuelMoisture[0][0] * Math.exp(constantsFineFuelMoisture[1][0] * deltaT);
} else if (deltaT <= diffTemperature[1]) {
ffm = constantsFineFuelMoisture[0][1] * Math.exp(constantsFineFuelMoisture[1][1] * deltaT);
} else if (deltaT <= diffTemperature[2]) {
ffm = constantsFineFuelMoisture[0][2] * Math.exp(constantsFineFuelMoisture[1][2] * deltaT);
} else {
ffm = constantsFineFuelMoisture[0][3] * Math.exp(constantsFineFuelMoisture[1][3] * deltaT);
}
/** if ffm is smaller than one, set it to one */
if (ffm < 1.) {
ffm = 1.;
}
/** adjust fine fuel moisture according to herb state */
if (herbstate == HerbState.TRANSITION) {
ffm = ffm + 5.;
} else if (herbstate == HerbState.GREEN) {
ffm = ffm + 10.;
}
return ffm;
}
public String classifyWhole(File file) {
double[] probabilities = new double[genres.length]; // array of initial probabilities.
int current = 0; // array counter.
for (MarkovModel mm : mms) // for every MarkovModel in the array.
{
probabilities[current] =
mm.probabilityWhole(file); // get initial probability from the Markov Model.
++current;
}
double[] realProbabilities = new double[genres.length]; // Array of calculated probabilities.
int max = 0; // Pointer to maximum probability.
for (int i = 0; i < genres.length; ++i) // Calculate probability for each genre.
{
double sum = 0;
for (int j = 0; j < genres.length; ++j) // Sum of the probabilities in different genres.
{
sum += Math.exp(probabilities[j]);
}
realProbabilities[i] = Math.exp(probabilities[i]) / sum; // Calculating final probability.
if (realProbabilities[i] > realProbabilities[max]) // recalculating max probability.
{
max = i;
}
}
for (int i = 0; i < genres.length; ++i) {
System.out.println(genres[i] + " : " + probabilities[i]);
}
return genres[max]; // returning corresponding genre.
}
/**
* Creates an undirected model that corresponds to a Boltzmann machine with the given weights and
* biases.
*
* @param weights
* @param biases
* @return An appropriate UndirectedModel.
*/
public static UndirectedModel createBoltzmannMachine(double[][] weights, double[] biases) {
if (weights.length != biases.length)
throw new IllegalArgumentException(
"Number of weights "
+ weights.length
+ " not equal to number of biases "
+ biases.length);
int numV = weights.length;
Variable vars[] = new Variable[numV];
for (int i = 0; i < numV; i++) vars[i] = new Variable(2);
UndirectedModel mdl = new UndirectedModel(vars);
for (int i = 0; i < numV; i++) {
Factor nodePtl = new TableFactor(vars[i], new double[] {1, Math.exp(biases[i])});
mdl.addFactor(nodePtl);
for (int j = i + 1; j < numV; j++) {
if (weights[i][j] != 0) {
double[] ptl = new double[] {1, 1, 1, Math.exp(weights[i][j])};
mdl.addFactor(vars[i], vars[j], ptl);
}
}
}
return mdl;
}
private double modelTurnbullWakemanAsian(
double S, double K, double r, double div, double sig, double T) {
// constant
double b = r - div; // cost of carry rate
double tau = 0.0; // time to the begining of the average period
double m1 = 0.0;
double m2 = 0.0;
double optionValue = 0.0;
double x = 0.0;
m1 = ((Math.exp(b * T) - Math.exp(b * tau)) / (b * (T - tau))) * S;
m2 =
Math.pow(S, 2)
* 2
* Math.exp((2 * b + Math.pow(sig, 2)) * T)
/ ((b + Math.pow(sig, 2)) * (2 * b + Math.pow(sig, 2)) * Math.pow(T - tau, 2))
+ (Math.pow(S, 2)
* 2
* Math.exp((2 * b + Math.pow(sig, 2)) * tau)
/ (b * Math.pow(T - tau, 2)))
* (1 / (2 * b + Math.pow(sig, 2))
- (Math.exp(b * (T - tau))) / (b + Math.pow(sig, 2)));
System.out.println("M:" + m2);
double modVol = Math.sqrt((1 / T) * Math.log(m2 / Math.pow(m1, 2))) * 100;
optionValue = modelBlack76(K, m1, modVol, T, r);
return optionValue;
}
public static double[] getExpData(double[] axis, double scale) {
double fraction = Math.exp(-axis[0]);
double[] buffer = new double[axis.length];
for (int loop = 0; loop < axis.length; loop++) {
buffer[loop] = scale * Math.exp(-axis[loop]) / fraction;
}
return buffer;
}
/**
* Computes x + y without losing precision using ln(x) and ln(y).
*
* @param lna Value.
* @param lnc Value.
* @return Result.
*/
public static double LogSum(float lna, float lnc) {
if (lna == Float.NEGATIVE_INFINITY) return lnc;
if (lnc == Float.NEGATIVE_INFINITY) return lna;
if (lna > lnc) return lna + Special.Log1p(Math.exp(lnc - lna));
return lnc + Special.Log1p(Math.exp(lna - lnc));
}
private void process(int op, double value) {
float c, v1, v2;
boolean resetMinMax = roiWidth == width && roiHeight == height && !(op == FILL);
c = (float) value;
for (int y = roiY; y < (roiY + roiHeight); y++) {
int i = y * width + roiX;
for (int x = roiX; x < (roiX + roiWidth); x++) {
v1 = pixels[i];
switch (op) {
case INVERT:
v2 = max - (v1 - min);
break;
case FILL:
v2 = fillColor;
break;
case ADD:
v2 = v1 + c;
break;
case MULT:
v2 = v1 * c;
break;
case GAMMA:
if (v1 <= 0f) v2 = 0f;
else v2 = (float) Math.exp(c * Math.log(v1));
break;
case LOG:
if (v1 <= 0f) v2 = 0f;
else v2 = (float) Math.log(v1);
break;
case EXP:
v2 = (float) Math.exp(v1);
break;
case SQR:
v2 = v1 * v1;
break;
case SQRT:
if (v1 <= 0f) v2 = 0f;
else v2 = (float) Math.sqrt(v1);
break;
case ABS:
v2 = (float) Math.abs(v1);
break;
case MINIMUM:
if (v1 < value) v2 = (float) value;
else v2 = v1;
break;
case MAXIMUM:
if (v1 > value) v2 = (float) value;
else v2 = v1;
break;
default:
v2 = v1;
}
pixels[i++] = v2;
}
}
if (resetMinMax) findMinAndMax();
}
