Title:
*Description:
*Copyright: Copyright (c) 2003
*Company:
* @author not attributable * @version 1.0 */ public interface Assessor { public double getCurrentValue(); } pal-1.5.1/src/pal/algorithmics/GeneralObjectState.java 0000644 0000000 0000000 00000002771 07742745450 021415 0 ustar root root package pal.algorithmics; /** *Title:
*Description:
*Copyright: Copyright (c) 2003
*Company:
* @author not attributable * @version 1.0 */ public class GeneralObjectState implements ObjectState { private final UndoableAction action_; private final StateProvider subject_; private final boolean maximise_; public GeneralObjectState(UndoableAction action, StateProvider subject, boolean maximise) { this.action_ = action; this.subject_ = subject; this.maximise_ = maximise; } /** * Perform an action * @param currentScore the current score before doing the action * @param desparationValue An indication of how desparate we are, values closer to 1 mean more desparate while values towards 0 mean less desparate * @return the current score after doing the action */ public double doAction(double currentScore, double desparationValue) { boolean succeeded = false; double score = currentScore; while(!succeeded) { score = action_.doAction(currentScore,desparationValue); succeeded = action_.isActionSuccessful(); } return score; } /** * * @return true if undo was successful */ public boolean undoAction() { return action_.undoAction(); } public Object getStateReference() { return subject_.getStateReference(); } public void restoreState(Object stateReference) { subject_.restoreState(stateReference); } public boolean isMaximiseScore() { return maximise_; } } pal-1.5.1/src/pal/algorithmics/UndoableAction.java 0000644 0000000 0000000 00000026444 10024070372 020557 0 ustar root root package pal.algorithmics; /** *Title: UndoableAction
*Description: A stateful, single thread object
*Copyright: Copyright (c) 2003
*Company:
* @author Matthew Goode * @version 1.0 */ import java.util.*; public interface UndoableAction { /** * Perform an action * @param currentscore The current score before doing the action * @param desparationValue An indication by the processing machines of willingness to do more extreme actions. A value of 0 means not desparate at all, a value of 1 means very desparate * @return the current score after doing the action (or the input score if not successful) */ public double doAction(double currentScore, double desparationValue); /** * Was the last action deterministic? That is, if it wasn't chosen and state is still as * before is it worth doing it again? * @return true if last action deterministic */ public boolean isActionDeterministic(); /** * Was the last call to doAction() succesful? * @return true if last action successful, false otherwise */ public boolean isActionSuccessful(); /** * Undo the last action (if it was successful) * Users of undoable actions should accept that sometimes it isn't possible. * If an undo was not possible the action should not change any state * @return true if undo was successful */ public boolean undoAction(); // -=-=-==-=--=-==--=-==--=-==---==-=--=-=-=-=-==-=-=-=-=-=-=--==-=-=--==-=--=- // -=-=-= Utils -=-=-=-=-=-=-==--==-=--=-=-=-=-==-=-=-=-=-=-=--==-=-=--==-=--=- // -=-=-==-=--=-==--=-==--=-==---==-=--=-=-=-=-==-=-=-=-=-=-=--==-=-=--==-=--=- public static final class Utils { /** * Create an action that selects uniformly from a number of sub actions * @param subActions * @return */ public static final UndoableAction getSimpleUniformSelection(UndoableAction[] subActions) { return new Multi(subActions); } /** * Create an action that selects uniformly from a number of sub actions * @param subActions * @param acitionProportions * @throws IllegalArgumentException if action array and proportion arrays are different lengths * @return */ public static final UndoableAction getDistributedSelection(UndoableAction[] subActions, double[] actionProportions) { if(subActions.length>actionProportions.length) { throw new IllegalArgumentException("Actions and proportion array different lengths"); } return new DistributedMulti(subActions, actionProportions); } /** * Create an action that combines multiple actions * @param subActions The actions that are do in turn. * @return An action that performs all the sub actions */ public static final UndoableAction getCombined(UndoableAction[] subActions) { return new Combined(subActions); } /** * A simple tool for change actions when things get desparate * @param primaryAction The main action to do when things are going well * @param desparateAction The action to do when things get desparate. The desperation value for the desparate action will be scaled according to how much over the limit we are * @param desparationLimit The desparate value at which we start doing the desparate action * @param desparationInterval The time between desparate actions when we cross the cutoff (a value of one will mean do all the time after desparation value has crossed cutoff) */ public static final UndoableAction getSimpleDesparation(UndoableAction primaryAction, UndoableAction desparateAction, double desparationLimit, int desparationInterval) { return new SimpleDesparation(primaryAction,desparateAction,desparationLimit,desparationInterval); } // -=-==-=--==--=-=-=-=-=-=-==--=-= private static class SimpleDesparation implements UndoableAction { private final UndoableAction primaryAction_; private final UndoableAction desparateAction_; private final double desparationLimit_; private final int desparationInterval_; private int currentDesparateCount_ = 0; private UndoableAction lastAction_ = null; /** * A simple tool for change actions when things get desparate * @param primaryAction The main action to do when things are going well * @param desparateAction The action to do when things get desparate. The desperation value for the desparate action will be scaled according to how much over the limit we are * @param desparationLimit The desparate value at which we start doing the desparate action * @param desparationInterval The time between desparate actions when we cross the cutoff (a value of one will mean do all the time after desparation value has crossed cutoff) */ public SimpleDesparation(UndoableAction primaryAction, UndoableAction desparateAction, double desparationLimit, int desparationInterval) { this.primaryAction_ = primaryAction; this.desparateAction_ = desparateAction; this.desparationLimit_ = desparationLimit; this.desparationInterval_ = desparationInterval; } /** * @return false */ public boolean isActionDeterministic() { return false; } public double doAction(double currentScore, double desparationValue) { if(desparationValue>=desparationLimit_) { currentDesparateCount_++; if(currentDesparateCount_==desparationInterval_) { currentDesparateCount_ = 0; lastAction_ = desparateAction_; desparationValue = (desparationLimit_-desparationValue)/(1-desparationLimit_); } else { lastAction_ = primaryAction_; } } else { lastAction_ = primaryAction_; currentDesparateCount_ = 0; } return lastAction_.doAction(currentScore,desparationValue); } public boolean isActionSuccessful() { if(lastAction_!=null) { return lastAction_.isActionSuccessful(); } throw new RuntimeException("Assertion error : isActionSuccessful() called when no action has been done recently"); } public boolean undoAction() { if(lastAction_!=null) { final boolean successful = lastAction_.undoAction(); lastAction_ = null; return successful; } else { throw new RuntimeException("Assertion error : undoAction() called when no action has been done recently (or has already been undone)"); } } } //End of class Multi // -=-==-=--==--=-=-=-=-=-=-==--=-= private static class Multi implements UndoableAction { private final UndoableAction[] subActions_; private UndoableAction lastAction_ = null; private final Random random_; public Multi(UndoableAction[] subActions) { this.subActions_ = subActions; this.random_ = new Random(); } public double doAction(double currentScore, double desparationValue) { lastAction_ = subActions_[random_.nextInt(subActions_.length)]; return lastAction_.doAction(currentScore,desparationValue); } public boolean isActionSuccessful() { if(lastAction_!=null) { return lastAction_.isActionSuccessful(); } throw new RuntimeException("Assertion error : isActionSuccessful() called when no action has been done recently"); } /** * @return false */ public boolean isActionDeterministic() { return false; } public boolean undoAction() { if(lastAction_!=null) { final boolean successful = lastAction_.undoAction(); lastAction_ = null; return successful; } else { throw new RuntimeException("Assertion error : undoAction() called when no action has been done recently (or has already been undone)"); } } } //End of class Multi // -=-==-=--==--=-=-=-=-=-=-==--=-= private static class DistributedMulti implements UndoableAction { private final UndoableAction[] subActions_; private final double[] probabilities_; private UndoableAction lastAction_ = null; private final Random random_; public DistributedMulti(UndoableAction[] subActions, double[] proportions) { this.subActions_ = subActions; this.probabilities_ = new double[subActions.length]; double total = 0; for(int i = 0 ; i < subActions.length ; i++) { total+=proportions[i]; } for(int i = 0 ; i < subActions.length ; i++) { probabilities_[i] = proportions[i]/total; } this.random_ = new Random(); } /** * @return false */ public boolean isActionDeterministic() { return false; } public double doAction(double currentScore, double desparationValue) { double v = random_.nextDouble(); double total = 0; int index = subActions_.length-1; for(int i = 0 ; i < subActions_.length ; i++) { total+=probabilities_[i]; if(total>v) { index = i; break; } } lastAction_ = subActions_[index]; return lastAction_.doAction(currentScore,desparationValue); } public boolean isActionSuccessful() { if(lastAction_!=null) { return lastAction_.isActionSuccessful(); } throw new RuntimeException("Assertion error : isActionSuccessful() called when no action has been done recently"); } public boolean undoAction() { if(lastAction_!=null) { boolean successful = lastAction_.undoAction(); lastAction_ = null; return successful; } else { throw new RuntimeException("Assertion error : undoAction() called when no action has been done recently (or has already been undone)"); } } } //End of class DistributedMulti // -=-==-=--==--=-=-=-=-=-=-==--=-= private static class Combined implements UndoableAction { private final UndoableAction[] subActions_; private boolean deterministic_ = true; private boolean successful_ = false; public Combined(UndoableAction[] subActions) { this.subActions_ = subActions; } /** * @return false */ public boolean isActionDeterministic() { return deterministic_; } public double doAction(double currentScore, double desparationValue) { boolean d = true; boolean s = true; for(int i = 0 ; i < subActions_.length ; i++) { UndoableAction a = subActions_[i]; double score = a.doAction(currentScore, desparationValue); if(a.isActionSuccessful()) { s = true; currentScore = score; d = d & a.isActionDeterministic(); } } deterministic_ = d; successful_ = s; return currentScore; } public boolean isActionSuccessful() { return successful_; } public boolean undoAction() { boolean result = true; if(successful_) { for(int i = subActions_.length -1 ; i >= 0 ; i++) { UndoableAction a = subActions_[i]; if(a.isActionSuccessful()) { result = result & a.undoAction(); } } successful_ = false; return result; } else { throw new RuntimeException("Assertion error : undoAction() called when not successful"); } } } //End of class Combined } //End of class Utils } pal-1.5.1/src/pal/algorithmics/StateProvider.java 0000644 0000000 0000000 00000000461 07742741016 020467 0 ustar root root package pal.algorithmics; /** *Title:
*Description:
*Copyright: Copyright (c) 2003
*Company:
* @author not attributable * @version 1.0 */ public interface StateProvider { public Object getStateReference(); public void restoreState(Object stateReference); } pal-1.5.1/src/pal/algorithmics/StoppingCriteria.java 0000644 0000000 0000000 00000037536 07762652372 021207 0 ustar root root // StoppingCriteria.java // // (c) 1999-2003 PAL Development Core Team // // This package may be distributed under the // terms of the Lesser GNU General Public License (LGPL) package pal.algorithmics; /** * Title: StoppingCriteria * Description: A means of deciding when to stop * @author Matthew Goode * @version 1.0 */ import pal.util.AlgorithmCallback; public interface StoppingCriteria extends java.io.Serializable { public boolean isTimeToStop(); /** * Get an indication of how close to stopping we currently are * @return a value between 0 and 1 where zero means not likely to stop soon, and a value of one means likely to stop very soon */ public double getRelativeStoppingRatio(); /** * @param externalStablized if true than other factors have stablized */ public void newIteration(double currentScore, double bestScore, boolean maximising, boolean externalStablized, AlgorithmCallback callback); public void reset(); //=========================================== //=========== Static Factory Class ============= //=========================================== public static interface Factory extends java.io.Serializable { public StoppingCriteria newInstance(); } //=========================================== //=========== Static Util Class ============= //=========================================== public static class Utils { /** * A stopping criteria that stops after a set number of iterations * @param maxIterationCount the maximum number of iterations. */ public static final StoppingCriteria.Factory getIterationCount(int maxIterationCount) { return new IterationCountSC.SCFactory(maxIterationCount); } /** * A stopping criteria that works by counting how many iterations occur at a given score (either the best score or the * current score) and stopping when score does not change after a set number of generations * @param maxIterationCountAtCurrentScore the number of iterations to wait at the current score before stopping * @param matchBestScore if true will examine the best score so far, else will examine the current score so far. */ public static final StoppingCriteria.Factory getUnchangedScore(int maxIterationCountAtCurrentScore, boolean matchBestScore) { return new UnchangedScoreSC.SCFactory(maxIterationCountAtCurrentScore, matchBestScore); } /** * A stopping criteria that works by counting how many iterations occur at a given score (either the best score or the * current score) and stopping when score does not change after a set number of generations * @param maxIterationCountAtCurrentScore the number of iterations to wait at the current score before stopping * @param matchBestScore if true will examine the best score so far, else will examine the current score so far. */ public static final StoppingCriteria.Factory getNonExactUnchangedScore(int maxIterationCountAtCurrentScore, boolean matchBestScore, double tolerance) { return new NonExactUnchangedScoreSC.SCFactory(maxIterationCountAtCurrentScore, matchBestScore, tolerance); } /** * A stopping criteria that is a composite of a set of criteria, stops when at least one * sub criteria wants to stop * @param subCriteria an array of StoppingCriteria to combine */ public static final StoppingCriteria.Factory getCombined(Factory[] subCriteria) { return new CombinedSC.SCFactory(subCriteria); } //Has Serialization code private static class IterationCountSC implements StoppingCriteria { int count_ = 0; int maxIterationCount_; // // Serialization code // private static final long serialVersionUID= -883722345529L; private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { out.writeByte(1); //Version number out.writeInt(count_); out.writeInt(maxIterationCount_); } private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException{ byte version = in.readByte(); switch(version) { default : { count_ = in.readInt(); maxIterationCount_ = in.readInt(); break; } } } public IterationCountSC(int maxIterationCount) { this.maxIterationCount_ = maxIterationCount; } public void reset() { count_ = 0; } /** * Goes up as the count nears maximum * @return */ public double getRelativeStoppingRatio() { return count_/(double)maxIterationCount_; } public boolean isTimeToStop() { return count_>=maxIterationCount_; } /** * @param externalStablized if true than other factors have stablized */ public void newIteration(double currentScore, double bestScore, boolean maximising, boolean externalStablized, AlgorithmCallback callback) { count_++; callback.updateProgress(count_/(double)maxIterationCount_); } // ===== Factory ========== private static class SCFactory implements Factory { private int maxIterationCount_; // // Serialization code // private static final long serialVersionUID = -552478345529L; private void writeObject( java.io.ObjectOutputStream out ) throws java.io.IOException { out.writeByte( 1 ); //Version number out.writeInt(maxIterationCount_); } private void readObject( java.io.ObjectInputStream in ) throws java.io.IOException, ClassNotFoundException { byte version = in.readByte(); switch( version ) { default: { maxIterationCount_ = in.readInt(); break; } } } public SCFactory(int maxIterationCount) { this.maxIterationCount_ = maxIterationCount; } public StoppingCriteria newInstance() { return new IterationCountSC(maxIterationCount_); } } } //Has Serialization code private static class CombinedSC implements StoppingCriteria { private StoppingCriteria[] subCriteria_; // // Serialization code // private static final long serialVersionUID= -847823472529L; private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { out.writeByte(1); //Version number out.writeObject(subCriteria_); } private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException{ byte version = in.readByte(); switch(version) { default : { subCriteria_ = (StoppingCriteria[])in.readObject(); break; } } } public CombinedSC(StoppingCriteria[] subCriteria) { this.subCriteria_ = subCriteria; } public void reset() { for(int i = 0 ; i < subCriteria_.length ; i++) { subCriteria_[i].reset(); } } public double getRelativeStoppingRatio() { double max = 0; for(int i = 0 ; i < subCriteria_.length ; i++) { max = Math.max(max,subCriteria_[i].getRelativeStoppingRatio()); } return max; } public boolean isTimeToStop() { for(int i = 0 ; i < subCriteria_.length ; i++) { if(subCriteria_[i].isTimeToStop()) { return true; } } return false; } /** * @param externalStablized if true than other factors have stablized */ public void newIteration(double currentScore, double bestScore, boolean maximising, boolean externalStablized, AlgorithmCallback callback) { for(int i = 0 ; i < subCriteria_.length ; i++) { subCriteria_[i].newIteration(currentScore,bestScore,maximising,externalStablized, callback); } } // ===== Factory ========== static class SCFactory implements Factory { Factory[] subCriteria_; // // Serialization code // private static final long serialVersionUID = -525566345529L; private void writeObject( java.io.ObjectOutputStream out ) throws java.io.IOException { out.writeByte( 1 ); //Version number out.writeObject(subCriteria_); } private void readObject( java.io.ObjectInputStream in ) throws java.io.IOException, ClassNotFoundException { byte version = in.readByte(); switch( version ) { default: { subCriteria_ = (Factory[])in.readObject(); break; } } } public SCFactory( Factory[] subCriteria ) { this.subCriteria_ = subCriteria; } public StoppingCriteria newInstance() { StoppingCriteria[] subs = new StoppingCriteria[subCriteria_.length]; for(int i = 0 ; i < subs.length ; i++) { subs[i] = subCriteria_[i].newInstance(); } return new CombinedSC(subs); } } } // -=-=-=-= //Has Serialization code private static class UnchangedScoreSC implements StoppingCriteria { private int count_ = 0; private int maxIterationCountAtCurrentScore_; private double lastScore_; private boolean matchBestScore_; // // Serialization code // private static final long serialVersionUID= -3242345529L; private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { out.writeByte(1); //Version number out.writeInt(count_); out.writeInt(maxIterationCountAtCurrentScore_); out.writeDouble(lastScore_); out.writeBoolean(matchBestScore_); } private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException{ byte version = in.readByte(); switch(version) { default : { count_ = in.readInt(); maxIterationCountAtCurrentScore_ = in.readInt(); lastScore_ = in.readDouble(); matchBestScore_ = in.readBoolean(); break; } } } public UnchangedScoreSC(int maxIterationCountAtCurrentScore, boolean matchBestScore) { this.maxIterationCountAtCurrentScore_ = maxIterationCountAtCurrentScore; this.matchBestScore_ = matchBestScore; } public void reset() { count_ = 0; } /** * Goes up as the count nears maximum * @return */ public double getRelativeStoppingRatio() { return count_/(double)maxIterationCountAtCurrentScore_; } public boolean isTimeToStop() { return count_>=maxIterationCountAtCurrentScore_; } /** * @param externalStablized if true than other factors have stablized */ public void newIteration(double currentScore, double bestScore, boolean maximising, boolean externalStablized, AlgorithmCallback callback){ if(!externalStablized) { return; } if(count_==0) { lastScore_ = (matchBestScore_ ? bestScore : currentScore); } else { if(matchBestScore_) { if((!maximising&&(bestScoreTitle: Object State
*Description: A stateful, single thread object, that can act upon itself
* @author Matthew Goode * @version 1.0 */ public interface ObjectState { /** * Perform an action * @param currentScore The current score before doing the action * @param desparationValue An indication by the processing machines of willingness to do more extreme actions. A value of 0 means not desparate at all, a value of 1 means very desparate * @return the current score after doing the action (or the input score if not successful) */ public double doAction(double currentScore, double desparationValue); /** * Undo the previous action if possible * @return true if undo was successful, false otherwise */ /** * Undo the last action (if it was successful) * Users of an ObjectState should accept that sometimes undoing an action isn't possible. * If an undo was not possible the object state should be in the same state as it was previous to the call to undoAction() * @return true if undo was successful */ public boolean undoAction(); /** * * @return An object that can be used to reconstruct the current state of this object */ public Object getStateReference(); /** * Used to restore the state of the this object to that of a previous time point * @param stateReference An object returned by getStateReference() */ public void restoreState(Object stateReference); /** * If true, than a bigger score is better, otherwise a smaller score is better * @return True if the aim is to maximise */ public boolean isMaximiseScore(); } pal-1.5.1/src/pal/algorithmics/Markable.java 0000644 0000000 0000000 00000000702 07742735450 017415 0 ustar root root // Markable.java // // (c) 1999-2001 PAL Development Core Team // // This package may be distributed under the // terms of the Lesser GNU General Public License (LGPL) package pal.algorithmics; /** *Title: Markable
*Description: An interface for objects that can have their state marked
* @author Matthew Goode * @version 1.0 */ public interface Markable { public void mark(); public void undoToMark(); } pal-1.5.1/src/pal/algorithmics/ProbabilityIterator.java 0000644 0000000 0000000 00000007725 07742735356 021712 0 ustar root root // ProbabilityIterator.java // // (c) 1999-2003 PAL Development Core Team // // This package may be distributed under the // terms of the Lesser GNU General Public License (LGPL) package pal.algorithmics; /** * A function for obtaining probabilities (that may change over time) * @author Matthew Goode */ public interface ProbabilityIterator { public double getNextProbability(double currentBest, double testValue, boolean maximising); public boolean isStablised(); public static interface Factory { public ProbabilityIterator newInstance(); } public static class Utils { public static final Factory getConstant(double value) { return new Constant.PIFactory(value); } public static final Factory getHillClimb() { return new HillClimb.PIFactory(); } public static final Factory getBoltzman(double initialTemperature, double temperatureDecay, int chainLength) { return new Boltzman.PIFactory(initialTemperature,temperatureDecay,chainLength); } //============================================================= private static class Constant implements ProbabilityIterator { double value_; public Constant(double value ) { this.value_ = value; } public double getNextProbability(double currentBest, double testValue, boolean maximising) { return value_; } public boolean isStablised() { return true; } static class PIFactory implements Factory { Constant intstance_; public PIFactory(double value ) { this.intstance_ = new Constant(value); } public ProbabilityIterator newInstance() { return intstance_; } } } private static class HillClimb implements ProbabilityIterator { public double getNextProbability(double currentBest, double testValue, boolean maximising) { if(maximising) { return(testValue>=currentBest ? 1 : 0); } return(testValue<=currentBest ? 1 : 0); } public boolean isStablised() { return true; } static class PIFactory implements Factory { private static final HillClimb INSTANCE = new HillClimb(); public ProbabilityIterator newInstance() { return INSTANCE; } } } // === Boltzman ==== private static class Boltzman implements ProbabilityIterator{ double initialTemperature_; double temperatureDecay_; int chainLength_; double k_ = 1; double currentTemperature_; int chainPosition_; public Boltzman(double initialTemperature, double temperatureDecay, int chainLength) { this.initialTemperature_ = initialTemperature; this.temperatureDecay_ = temperatureDecay; this.chainLength_ = chainLength; this.currentTemperature_ = initialTemperature_; this.chainPosition_ = 0; } public boolean isStablised() { return currentTemperature_<0.005; } public double getNextProbability(double currentValue, double newValue, boolean maximising) { double toReturn; if(maximising) { if(newValue>currentValue) { toReturn = 1; } else { toReturn = Math.exp(-(currentValue-newValue)/(k_*currentTemperature_)); } } else { if(newValueDescription: An UnconstrainedLikelihoodModel object must be treated as a stateful, single threaded object that can be used * for calculating components in an overall likelihood calculation.
*UnconstrainedLikelihoodModel is a generalisation of the LHCalculator code, that no longer refers to SubstitutionModel directly (this is still need for other code though so LHCalculator remains)
*History
*
Title: SimpleMolecularClockLikelihoodModel
*Description:
* @author Matthew Goode * @version 1.0 */ import java.io.*; import pal.datatype.*; import pal.math.*; import pal.misc.*; import pal.substmodel.*; public class SingleSplitMolecularClockLikelihoodModel implements MolecularClockLikelihoodModel { private static final boolean isUseLowerModelOnly(double changeHeight, double beforeSplitHeight, double lowerHeight) { return (changeHeight>=beforeSplitHeight); } private static final boolean isUseUpperSampleOnly(double changeHeight, double beforeSplitHeight, double afterSplitHeight) { return (changeHeight<=afterSplitHeight); } // -=-=--==-=-=-=---=-==-=--==-=-=-=- private static final class ExternalImpl implements External { private final LHCalculator.External base_; private final CombineModel model_; private final HeightConverter heightConverter_; public ExternalImpl(LHCalculator.External base, CombineModel model, HeightConverter heightConverter) { this.base_ = base; this.model_ = model; this.heightConverter_ = heightConverter; } public void calculateSingleExtendedConditionals(double topBaseHeight, double bottomBaseHeight, int numberOfPatterns, ConditionalProbabilityStore baseConditionalProbabilities, ConditionalProbabilityStore resultConditionalProbabilities) { model_.setup(bottomBaseHeight,heightConverter_,false); base_.calculateSingleExtendedIndirect(model_.getAdjustedDistance(topBaseHeight), model_,numberOfPatterns,baseConditionalProbabilities,resultConditionalProbabilities); } public void calculateSingleDescendentExtendedConditionals( double topBaseHeight, double bottomBaseHeight, PatternInfo centerPattern, ConditionalProbabilityStore descendentConditionalProbabilities ) { model_.setup(bottomBaseHeight,heightConverter_,false); base_.calculateSingleExtendedDirect(model_.getAdjustedDistance(topBaseHeight), model_,centerPattern.getNumberOfPatterns(),descendentConditionalProbabilities); } /** */ public void calculateSingleAscendentExtendedConditionalsDirect( double topBaseHeight, double bottomBaseHeight, PatternInfo centerPattern, ConditionalProbabilityStore ascendentConditionalProbabilityProbabilties ) { // System.out.println("**** ASCENDENT 3************"); model_.setup(bottomBaseHeight,heightConverter_,true); base_.calculateSingleExtendedDirect(model_.getAdjustedDistance(topBaseHeight), model_,centerPattern.getNumberOfPatterns(),ascendentConditionalProbabilityProbabilties); } /** */ public void calculateSingleAscendentExtendedConditionalsIndirect( double topBaseHeight, double bottomBaseHeight, PatternInfo centerPattern, ConditionalProbabilityStore baseAscendentConditionalProbabilityProbabilties, ConditionalProbabilityStore resultConditionalProbabilityProbabilties ) { // System.out.println("**** ASCENDENT 2************"); model_.setup(bottomBaseHeight,heightConverter_,true); base_.calculateSingleExtendedIndirect(model_.getAdjustedDistance(topBaseHeight), model_,centerPattern.getNumberOfPatterns(),baseAscendentConditionalProbabilityProbabilties,resultConditionalProbabilityProbabilties); } public void calculateExtendedConditionals( double topBaseHeight, double bottomBaseHeight, PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilities, ConditionalProbabilityStore rightConditionalProbabilities, ConditionalProbabilityStore resultStore ) { model_.setup(bottomBaseHeight,heightConverter_,false); base_.calculateExtended(model_.getAdjustedDistance(topBaseHeight), model_,centerPattern,leftConditionalProbabilities,rightConditionalProbabilities,resultStore); } /** * Calculate the likelihood given a non root node * @param nodeHeight the height of node doing the likelihood calculation * @param centerPatter assumed left is ascendent component, right is descendent * @param ascendentConditionalProbabilities Assumed to be extended (downwards) to the nodeHeight * @param descendentConditionalProbabilities Assumed to be extended (upwards) to the nodeHeight * @return the Log likelihood */ public double calculateLogLikelihoodNonRoot( double nodeHeight, PatternInfo centerPattern, ConditionalProbabilityStore ascendentConditionalProbabilitiesStore, ConditionalProbabilityStore descendentConditionalProbabilitiesStore ) { model_.setup(nodeHeight,heightConverter_,false); return base_.calculateLogLikelihood(model_,centerPattern,ascendentConditionalProbabilitiesStore,descendentConditionalProbabilitiesStore); } /** * Calculate the likelihood given two sub trees (left, right) and their extended likeihood probabilities * @param rootHeight the height of the likelihood calculation * @param leftConditionalProbabilities Assumed to be extended to the rootHeight * @param rightConditionalProbabilities Assumed to be extended to the rootHeight * @return the Log likelihood */ public double calculateLogLikelihood( double rootHeight, PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilitiesStore, ConditionalProbabilityStore rightConditionalProbabilitiesStore ) { model_.setup(rootHeight,heightConverter_,false); return base_.calculateLogLikelihood(model_,centerPattern,leftConditionalProbabilitiesStore,rightConditionalProbabilitiesStore); } public double calculateLogLikelihoodSingle( double rootHeight, PatternInfo centerPattern, ConditionalProbabilityStore conditionalProbabilitiesStore ) { model_.setup(rootHeight,heightConverter_,false); return base_.calculateLogLikelihoodSingle(model_,centerPattern.getPatternWeights(),centerPattern.getNumberOfPatterns(),conditionalProbabilitiesStore); } public void calculateFlatConditionals( double rootHeight, PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilitiesStore, ConditionalProbabilityStore rightConditionalProbabilitiesStore, ConditionalProbabilityStore resultConditionalProbabilitiesStore) { model_.setup(rootHeight,heightConverter_,false); base_.calculateFlat(centerPattern,leftConditionalProbabilitiesStore,rightConditionalProbabilitiesStore,resultConditionalProbabilitiesStore); } public SiteDetails calculateSiteDetails( double rootHeight, PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilitiesStore, ConditionalProbabilityStore rightConditionalProbabilitiesStore ) { model_.setup(rootHeight,heightConverter_,false); return base_.calculateSiteDetailsRooted(model_,centerPattern, leftConditionalProbabilitiesStore,rightConditionalProbabilitiesStore); } public void calculateFlatConditionals( double rootHeight, PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilitiesStore, ConditionalProbabilityStore rightConditionalProbabilitiesStore, ConditionalProbabilityStore resultConditionalProbabilitiesStore, double[] sampleHeights) { model_.setup(rootHeight,heightConverter_,false); base_.calculateFlat(centerPattern,leftConditionalProbabilitiesStore,rightConditionalProbabilitiesStore,resultConditionalProbabilitiesStore); } } // -=-=--==-=-=-=---=-==-=--==-=-=-=- private static final class LeafImpl implements Leaf { private final LHCalculator.Leaf base_; private final CombineModel model_; private final int numberOfPatterns_; private final HeightConverter heightConverter_; public LeafImpl(LHCalculator.Leaf base, CombineModel model, int numberOfPatterns, HeightConverter heightConverter) { this.base_ = base; this.model_ = model; this.numberOfPatterns_ = numberOfPatterns; this.heightConverter_ = heightConverter; } public ConditionalProbabilityStore calculateExtendedConditionals(double topBaseHeight, double bottomBaseHeight) { model_.setup(bottomBaseHeight,heightConverter_,false); return base_.getExtendedConditionalProbabilities(model_.getAdjustedDistance(topBaseHeight),model_,true); } public ConditionalProbabilityStore calculateFlatConditionals(double relatedHeight) { return base_.getFlatConditionalProbabilities(); } } private static final class InternalImpl implements Internal { private final LHCalculator.Internal base_; private final CombineModel model_; private final HeightConverter heightConverter_; public InternalImpl(LHCalculator.Generator generator, CombineModel model, HeightConverter heightConverter) { this.base_ = generator.createNewInternal(); this.model_ = model; this.heightConverter_ = heightConverter; } public ConditionalProbabilityStore calculatePostExtendedFlatConditionals( double topBaseHeight, double bottomBaseHeight, PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilityProbabilties, ConditionalProbabilityStore rightConditionalProbabilityProbabilties ) { model_.setup(bottomBaseHeight,heightConverter_,false); return base_.calculatePostExtendedFlat(model_.getAdjustedDistance(topBaseHeight), model_,centerPattern,leftConditionalProbabilityProbabilties,rightConditionalProbabilityProbabilties,true); } public ConditionalProbabilityStore calculateExtendedConditionals( final double topBaseHeight, final double bottomBaseHeight, final PatternInfo centerPattern, final ConditionalProbabilityStore leftConditionalProbabilityProbabilties, final ConditionalProbabilityStore rightConditionalProbabilityProbabilties ) { model_.setup(bottomBaseHeight,heightConverter_,false); return base_.calculateExtended(model_.getAdjustedDistance(topBaseHeight), model_,centerPattern,leftConditionalProbabilityProbabilties,rightConditionalProbabilityProbabilties,true); } public ConditionalProbabilityStore calculateAscendentExtendedConditionals( double topBaseHeight, double bottomBaseHeight, PatternInfo centerPattern, ConditionalProbabilityStore ascenedentConditionalProbabilityProbabilties, ConditionalProbabilityStore otherConditionalProbabilityProbabilties ) { // System.out.println("**** ASCENDENT 1************"); model_.setup(bottomBaseHeight,heightConverter_,true); return base_.calculateExtended(model_.getAdjustedDistance(topBaseHeight), model_,centerPattern,ascenedentConditionalProbabilityProbabilties,otherConditionalProbabilityProbabilties,true); } public ConditionalProbabilityStore calculateAscendentFlatConditionals( PatternInfo centerPattern, ConditionalProbabilityStore ascenedentConditionalProbabilityProbabilties, ConditionalProbabilityStore otherConditionalProbabilityProbabilties ) { // System.out.println("**** ASCENDENT FLAT ************"); return base_.calculateFlat(centerPattern,ascenedentConditionalProbabilityProbabilties,otherConditionalProbabilityProbabilties); } public ConditionalProbabilityStore calculateFlatConditionals( final PatternInfo centerPattern, final ConditionalProbabilityStore leftConditionalProbabilityProbabilties, final ConditionalProbabilityStore rightConditionalProbabilityProbabilties ) { return base_.calculateFlat(centerPattern,leftConditionalProbabilityProbabilties,rightConditionalProbabilityProbabilties); } } // -=-=--==-=-=-=---=-==-=--==-=-=-=- public static final Instance createInstance(RateMatrixGroup beforeSplitMatrices, RateMatrixGroup afterSplitMatrics, NeoParameterized acrossSplitParameters, SingleSplitDistribution probabilityModel, LHCalculator.Factory baseFactory, double splitTime) { int numberOfBaseCategories = beforeSplitMatrices.getNumberOfTransitionCategories(); DataType dt = beforeSplitMatrices.getDataType(); return new SimpleInstance(beforeSplitMatrices, afterSplitMatrics, acrossSplitParameters, probabilityModel, splitTime, baseFactory.createSeries( numberOfBaseCategories*numberOfBaseCategories, dt )); } public static final Instance createInstance(RateMatrixGroup beforeSplitMatrices, RateMatrixGroup afterSplitMatrics, NeoParameterized acrossSplitParameters, SingleSplitDistribution probabilityModel, double splitTime) { return createInstance(beforeSplitMatrices,afterSplitMatrics,acrossSplitParameters, probabilityModel,SimpleLHCalculator.getFactory(),splitTime); } public static final Instance createInstance(RateMatrixGroup beforeSplitMatrices, RateMatrixGroup afterSplitMatrics, NeoParameterized acrossSplitParameters, double splitTime) { return createInstance(beforeSplitMatrices,afterSplitMatrics, acrossSplitParameters,new SaturatedSingleSplitDistribution(beforeSplitMatrices.getNumberOfTransitionCategories()),SimpleLHCalculator.getFactory(),splitTime); } public static final Instance createInstance(RateMatrixGroup beforeSplitMatrices, RateMatrixGroup afterSplitMatrics, NeoParameterized acrossSplitParameters, double[] classProbabilities, double splitTime) { SingleSplitDistribution pm; int numberOfClasses = beforeSplitMatrices.getNumberOfTransitionCategories(); if(classProbabilities.length == numberOfClasses) { double[] result = new double[numberOfClasses*numberOfClasses]; for(int i = 0 ; i < numberOfClasses ; i++) { result[i*numberOfClasses+i] = classProbabilities[i]; } pm = new SaturatedSingleSplitDistribution(beforeSplitMatrices.getNumberOfTransitionCategories(),result ); } else { pm = new SaturatedSingleSplitDistribution( beforeSplitMatrices.getNumberOfTransitionCategories(),classProbabilities ); } return createInstance(beforeSplitMatrices,afterSplitMatrics,acrossSplitParameters,pm,SimpleLHCalculator.getFactory(),splitTime); } private static final class SimpleInstance implements Instance, java.io.Serializable { private final LHCalculator.Generator baseGenerator_; private final TotalModel totalModel_; public SimpleInstance(RateMatrixGroup beforeSplitModel, RateMatrixGroup afterSplitModel, NeoParameterized acrossSplitParameters, SingleSplitDistribution probabilityModel, double splitTime, LHCalculator.Generator baseGenerator) { this.totalModel_ = new TotalModel(beforeSplitModel,afterSplitModel,acrossSplitParameters, probabilityModel, splitTime,baseGenerator.createNewExternal()); this.baseGenerator_ = baseGenerator; } public NeoParameterized getSubstitutionModelParameterAccess() {return totalModel_; } public boolean hasSubstitutionModelParameters(){ return true; } public Leaf createNewLeaf(HeightConverter heightConverter, PatternInfo pattern, int[] patternStateMatchup) { return new LeafImpl( baseGenerator_.createNewLeaf( patternStateMatchup,pattern.getNumberOfPatterns() ), totalModel_.getCombineModel(), pattern.getNumberOfPatterns(), heightConverter ); } public External createNewExternal(HeightConverter heightConverter) { return new ExternalImpl( baseGenerator_.createNewExternal(), totalModel_.getCombineModel(), heightConverter); } public Internal createNewInternal(HeightConverter heightConverter) { return new InternalImpl( baseGenerator_, totalModel_.getCombineModel(), heightConverter ); } public ConditionalProbabilityStore createAppropriateConditionalProbabilityStore( boolean isForLeaf ) { return baseGenerator_.createAppropriateConditionalProbabilityStore(isForLeaf); } public String getSubstitutionModelSummary() { return "Model:"+totalModel_.getSummary(); } public NeoParameterized getParameterAccess() { return totalModel_; } } // -=-=--==-=-=-=---=-==-=--==-=-=-=- // ================================================================================================= // ================================ TotalModel ===================================================== // ================================================================================================= private final static class TotalModel implements java.io.Serializable, NeoParameterized { //Serialized variables private final SingleSplitDistribution probabilityModel_; private final CombineModel combineModel_; private final int numberOfProbabilityParameters_; private final int numberOfParameters_; public TotalModel(RateMatrixGroup beforeSplitMatrices, RateMatrixGroup afterSplitMatrices, NeoParameterized acrossSplitParameters, SingleSplitDistribution probabilityModel, double splitHeight, LHCalculator.External externalCalculator) { this.probabilityModel_ = probabilityModel; this.numberOfProbabilityParameters_ = probabilityModel.getNumberOfParameters(); this.combineModel_ = new CombineModel(this, beforeSplitMatrices, afterSplitMatrices, acrossSplitParameters, probabilityModel.getNumberOfBaseTransitionCategories(), splitHeight, externalCalculator); this.numberOfParameters_ = probabilityModel.getNumberOfParameters()+combineModel_.getNumberOfParameters(); } public final int getNumberOfTransitionCategories() { return combineModel_.getNumberOfTransitionCategories(); } public final double[][] getBaseCategoryProbabilities() { return probabilityModel_.getDistributionInfo(); } public final CombineModel getCombineModel() { return combineModel_; } public String getSummary() { return "Distribution:"+probabilityModel_+"\nModel:"+combineModel_.getSummary(); } public int getNumberOfParameters() { return numberOfParameters_; } public void setParameters(double[] parameters, int startIndex) { probabilityModel_.setParameters(parameters,startIndex); combineModel_.setParameters(parameters,startIndex+numberOfProbabilityParameters_); } public void getParameters(double[] parameterStore, int startIndex) { probabilityModel_.getParameters(parameterStore,startIndex); combineModel_.getParameters(parameterStore,startIndex+numberOfProbabilityParameters_); } public double getLowerLimit(int n) { if(nDescription: A wrapper around LHCalculator stuff
* @author Matthew Goode * @version 1.0 */ import pal.misc.*; import pal.substmodel.*; public class SimpleUnconstrainedLikelihoodModel implements UnconstrainedLikelihoodModel { private static final class ExternalImpl implements External { private final LHCalculator.External base_; private final SubstitutionModel model_; public ExternalImpl(LHCalculator.External base, SubstitutionModel model) { this.base_ = base; this.model_ = model; } public void calculateFlat( PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilities, ConditionalProbabilityStore rightConditionalProbabilities, ConditionalProbabilityStore resultStore ) { base_.calculateFlat(centerPattern, leftConditionalProbabilities, rightConditionalProbabilities, resultStore); } public void calculateExtended( double distance, PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilities, ConditionalProbabilityStore rightConditionalProbabilities, ConditionalProbabilityStore resultStore ) { base_.calculateExtended(distance,model_,centerPattern,leftConditionalProbabilities,rightConditionalProbabilities,resultStore); } public void calculateSingleExtendedDirect( double distance, int numberOfPatterns, ConditionalProbabilityStore conditionalProbabilities ) { base_.calculateSingleExtendedDirect(distance,model_,numberOfPatterns,conditionalProbabilities); } public void calculateSingleExtendedIndirect( double distance, int numberOfPatterns, ConditionalProbabilityStore baseConditionalProbabilities, ConditionalProbabilityStore resultConditionalProbabilities ) { base_.calculateSingleExtendedIndirect(distance,model_,numberOfPatterns,baseConditionalProbabilities,resultConditionalProbabilities); } public double calculateLogLikelihood( double distance, PatternInfo centerPattern, ConditionalProbabilityStore leftFlatConditionalProbabilities, ConditionalProbabilityStore rightFlatConditionalProbabilities, ConditionalProbabilityStore tempStore ) { return base_.calculateLogLikelihood(distance,model_,centerPattern,leftFlatConditionalProbabilities,rightFlatConditionalProbabilities,tempStore); } public double calculateLogLikelihood( PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilities, ConditionalProbabilityStore rightConditionalProbabilities ) { return base_.calculateLogLikelihood(model_,centerPattern,leftConditionalProbabilities,rightConditionalProbabilities); } public double calculateLogLikelihoodSingle( int[] patternWeights, int numberOfPatterns, ConditionalProbabilityStore conditionalProbabilityStore) { return base_.calculateLogLikelihoodSingle(model_,patternWeights,numberOfPatterns,conditionalProbabilityStore); } public SiteDetails calculateSiteDetailsRooted( PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilitiesStore, ConditionalProbabilityStore rightConditionalProbabilitiesStore ) { return base_.calculateSiteDetailsRooted(model_,centerPattern,leftConditionalProbabilitiesStore,rightConditionalProbabilitiesStore); } public SiteDetails calculateSiteDetailsUnrooted( double distance, PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilitiesStore, ConditionalProbabilityStore rightConditionalProbabilitiesStore, ConditionalProbabilityStore tempStore ) { return base_.calculateSiteDetailsUnrooted(distance,model_,centerPattern,leftConditionalProbabilitiesStore,rightConditionalProbabilitiesStore,tempStore); } } //End of class ExternalImpl // ================================================================================================= // ================= Internal ====================================================================== // ================================================================================================= public static final class InternalImpl implements Internal { private final LHCalculator.Internal base_; private final SubstitutionModel model_; public InternalImpl(LHCalculator.Internal base, SubstitutionModel model) { this.base_ = base; this.model_ = model; } public ConditionalProbabilityStore calculateFlat( PatternInfo centerPattern, ConditionalProbabilityStore leftConditionalProbabilities, ConditionalProbabilityStore rightConditionalProbabilities ) { return base_.calculateFlat(centerPattern,leftConditionalProbabilities,rightConditionalProbabilities); } public ConditionalProbabilityStore calculateExtended( double distance, PatternInfo centerPattern, final ConditionalProbabilityStore leftConditionalProbabilities, final ConditionalProbabilityStore rightConditionalProbabilities) { return base_.calculateExtended(distance,model_,centerPattern,leftConditionalProbabilities,rightConditionalProbabilities,true); } } //End of class InternalImpl // ================================================================================================= // ================= Leaf ========================================================================== // ================================================================================================= public static final class LeafImpl implements Leaf { private final LHCalculator.Leaf base_; private final SubstitutionModel model_; public LeafImpl(LHCalculator.Leaf base, SubstitutionModel model) { this.base_ = base; this.model_ = model; } public ConditionalProbabilityStore getFlatConditionalProbabilities() { return base_.getFlatConditionalProbabilities(); } public ConditionalProbabilityStore getExtendedConditionalProbabilities( double distance) { return base_.getExtendedConditionalProbabilities(distance,model_,true); } public Leaf getCopy() { return new LeafImpl(base_.getCopy(), model_); } } private static final class InstanceImpl implements Instance { private final LHCalculator.Generator base_; private final SubstitutionModel model_; private final NeoParameterized parameterAccess_; public InstanceImpl(LHCalculator.Generator base, SubstitutionModel model) { this.base_ = base; this.model_ = model; this.parameterAccess_ = new ParameterizedNeoWrapper(model); } public Leaf createNewLeaf(int[] patternStateMatchup, int numberOfPatterns) { return new LeafImpl(base_.createNewLeaf(patternStateMatchup,numberOfPatterns),model_); } public External createNewExternal() { return new ExternalImpl(base_.createNewExternal(),model_); } public Internal createNewInternal() { return new InternalImpl(base_.createNewInternal(),model_); } public boolean isAllowCaching() { return base_.isAllowCaching(); } public ConditionalProbabilityStore createAppropriateConditionalProbabilityStore( boolean isForLeaf ) { return base_.createAppropriateConditionalProbabilityStore(isForLeaf); } public String getSubstitutionModelSummary() { return model_.toString(); } public NeoParameterized getParameterAccess() { return parameterAccess_; } } /** * Create a SimpleUnconstrainedLikelihoodModel instance * * @param base The base LHCalculator generator to utilise * @param model The substitution model * @return An appropriate UnconstrianedLikelihoodModel instance */ public static final Instance createInstance(LHCalculator.Generator base, SubstitutionModel model) { return new InstanceImpl(base,model); } /** * Create a SimpleUnconstrainedLikelihoodModel instance * * @param base The base LHCalculator generator to utilise * @param model The substitution model * @return An appropriate UnconstrianedLikelihoodModel instance */ public static final Instance createInstance(LHCalculator.Factory base, SubstitutionModel model) { return new InstanceImpl(base.createSeries(model.getNumberOfTransitionCategories(),model.getDataType()),model); } } pal-1.5.1/src/pal/eval/DemographicLikelihoodValue.java 0000644 0000000 0000000 00000002401 10141732034 021340 0 ustar root root // DemographicLikelihoodValue.java // // (c) 1999-2001 PAL Development Core Team // // This package may be distributed under the // terms of the Lesser GNU General Public License (LGPL) // - partial likelihoods need a lot of memory storage // memory usage could be opimized by working in a single site package pal.eval; import pal.alignment.*; import pal.coalescent.*; /** * Estimates the likelihood for a tree using a specified * model of sequence evolution and a sequence alignment and * a specific demographic model as a prior on coalescent intervals. * * Must be used in conjunction with DemographicClockTree! * * @version $Id: DemographicLikelihoodValue.java,v 1.2 2001/07/13 14:39:13 korbinian Exp $ * * @author Alexei Drummond */ public class DemographicLikelihoodValue extends LikelihoodValue { // // Public stuff // /** * Parameter taking a site pattern. */ public DemographicLikelihoodValue(SitePattern sp) { super(sp); } /** * compute log-likelihood * for current branch lengths and model * * return negative log-likelihood */ public double compute() { super.compute(); logL += ((DemographicTree)tree).computeDemoLogLikelihood(); return -logL; } } pal-1.5.1/src/pal/eval/SimpleLikelihoodCalculator.java 0000644 0000000 0000000 00000021363 10141732164 021400 0 ustar root root // SimpleLikelihoodCalculator.java // // (c) 1999-2001 PAL Development Core Team // // This package may be distributed under the // terms of the Lesser GNU General Public License (LGPL) package pal.eval; /** * Only to be used by one thread. Based on the LikelihoodValue class but does not allow the use of * a rate distribution. * @author Korbinian Strimmer * @author Matthew Goode * @deprecated see new likelihood framework */ import pal.alignment.*; import pal.datatype.*; import pal.substmodel.*; import pal.tree.*; public class SimpleLikelihoodCalculator implements LikelihoodCalculator { SitePattern sitePattern_; Tree tree_; RateMatrix model_; DataType patternDatatype_; boolean modelChanged_ = false; /* Work variables */ private double[][][] partials_; /** [numberOfNodes] [numberOfPatterns] [numberOfStates] */ /* Cached variables */ private int numberOfStates_; private int numberOfPatterns_; //private int numberOfNodes_; private double[] frequency_; /** log-likelihood for each site pattern */ private double[] siteLogL_; /** Need to use setTree(), and setModel() before using compute() if you use this constructor */ public SimpleLikelihoodCalculator(SitePattern pattern) { setPattern(pattern); } private void setPattern(SitePattern pattern) { this.sitePattern_ = pattern; this.patternDatatype_ = sitePattern_.getDataType(); numberOfPatterns_ = sitePattern_.numPatterns; siteLogL_ = new double[numberOfPatterns_]; } public SimpleLikelihoodCalculator(SitePattern pattern, Tree tree, RateMatrix model) { setPattern(pattern); setTree(tree); setRateMatrix(model); } /** * Doesn't do anything... */ public void release() { } /** * compute log-likelihood for current tree (fixed branch lengths and model) * * return log-likelihood */ public double calculateLogLikelihood() { return treeLikelihood(); } public SitePattern getSitePattern() { return sitePattern_; } public Tree getTree() { return tree_; } /** * define model * (a site pattern must have been set before calling this method) * * @param m model of substitution (rate matrix + rate distribution) */ public void setRateMatrix(RateMatrix m) { if(m==null) { throw new RuntimeException("Assertion error : SetModel called with null model!"); } model_ = m; frequency_ = model_.getEquilibriumFrequencies(); numberOfStates_ = model_.getDataType().getNumStates(); int maxNodes = 2*sitePattern_.getSequenceCount()-2; allocatePartialMemory(maxNodes); } /** * define tree *,(must only be called only after a site pattern has been defined). * * @param t tree */ public void setTree(Tree t) { tree_ = t; if(t==null) { throw new RuntimeException("Assertion error : SetTree called with null tree!"); } // Assign sequences to leaves int[] alias = TreeUtils.mapExternalIdentifiers(sitePattern_, tree_); for (int i = 0; i < tree_.getExternalNodeCount(); i++) { tree_.getExternalNode(i).setSequence(sitePattern_.pattern[alias[i]]); } } public final void modelUpdated() { setRateMatrix(model_); } public final void treeUpdated() { setTree(tree_); } //=============================================================================== //======================= Non Public Stuff ====================================== //=============================================================================== private void allocatePartialMemory(int numberOfNodes) { // I love the profiler! // This 'if' statement sped my MCMC algorithm up by nearly 300% // Never underestimate the time it takes to allocate and de-allocate memory! // AD if ( (partials_ == null) || (numberOfNodes != partials_.length) || (numberOfPatterns_ != partials_[0].length) || (numberOfStates_ != partials_[0][0].length)) { partials_ = new double[numberOfNodes][numberOfPatterns_][numberOfStates_]; } } private int getKey(Node node) { if (node.isLeaf()) { return node.getNumber(); } return node.getNumber() + tree_.getExternalNodeCount(); } /** get partial likelihood of a branch */ protected double[][] getPartial(Node branch) { return partials_[getKey(branch)]; } /** get next branch around a center node (center may be root, and root may also be returned) */ private Node getNextBranchOrRoot(Node branch, Node center) { int numChilds = center.getChildCount(); int num; for (num = 0; num < numChilds; num++) { if (center.getChild(num) == branch) { break; } } // num is now child number (if num = numChilds then branch == center) // next node num++; if (num > numChilds) { num = 0; } if (num == numChilds) { return center; } else { return center.getChild(num); } } /** get next branch around a center node (center may be root, but root is never returned) */ protected Node getNextBranch(Node branch, Node center) { Node b = getNextBranchOrRoot(branch, center); if (b.isRoot()) { b = b.getChild(0); } return b; } /** multiply partials into the neighbour of branch */ protected void productPartials( Node center) { int numBranches = NodeUtils.getUnrootedBranchCount(center); Node nextBranch = center.getChild(0); double[][] partial = getPartial(nextBranch); for (int i = 1; i < center.getChildCount(); i++) { nextBranch = center.getChild(i); double[][] partial2 = getPartial(nextBranch); for (int patternIndex = 0; patternIndex < numberOfPatterns_; patternIndex++) { double[] p = partial[patternIndex]; double[] p2 = partial2[patternIndex]; for (int state = 0; state < numberOfStates_; state++) { p[state] *= p2[state]; } } } } /** compute partials for branch around center node (it is assumed that multiplied partials are available in the neighbor branch) */ protected void partialsInternal( Node center) { double[][] partial = getPartial(center); double[][] multPartial = getPartial(center.getChild(0)); model_.setDistance(center.getBranchLength()); for (int l = 0; l < numberOfPatterns_; l++) { double[] p = partial[l]; double[] mp = multPartial[l]; for (int d = 0; d < numberOfStates_; d++) { double sum = 0; for (int j = 0; j < numberOfStates_; j++) { sum += model_.getTransitionProbability(d, j)*mp[j]; } p[d] = sum; } } } /** compute partials for external branch */ protected void partialsExternal(Node branch) { double[][] partial = getPartial(branch); byte[] seq = branch.getSequence(); model_.setDistance(branch.getBranchLength()); for (int patternIndex = 0; patternIndex < numberOfPatterns_; patternIndex++) { double[] p = partial[patternIndex]; int endState = seq[patternIndex]; if(patternDatatype_.isUnknownState(endState)) { //A neater way of writing things but it may slow things down... //if (endState == numberOfStates_) { //Is this an gap? (A gap should be registered as unknown!) for (int startState = 0; startState < numberOfStates_; startState++) { p[startState] = 1; } } else { for (int startState = 0; startState < numberOfStates_; startState++) { p[startState] = model_.getTransitionProbability( startState, endState); } } } } private void traverseTree(Node currentNode){ if(currentNode.isLeaf()){ partialsExternal(currentNode); } else { for(int i = 0 ; i < currentNode.getChildCount() ; i++) { traverseTree(currentNode.getChild(i)); } if(!currentNode.isRoot()) { productPartials(currentNode); partialsInternal(currentNode); } } } /** returns number of branches centered around an internal node */ private int getBranchCount(Node center) { if (center.isRoot()) { return center.getChildCount(); } else { return center.getChildCount()+1; } } /** calculate likelihood of any tree and infer MAP estimates of rates at a site */ private double treeLikelihood() { //initPartials(); Node center = tree_.getRoot(); traverseTree(center); Node firstBranch = center.getChild(0); Node lastBranch = center.getChild(center.getChildCount()-1); double[][] partial1 = getPartial(firstBranch); productPartials(center); double logL = 0; for (int patternIndex = 0; patternIndex < numberOfPatterns_; patternIndex++) { double sum = 0; double[] p1 = partial1[patternIndex]; for (int d = 0; d < numberOfStates_; d++) { sum += frequency_[d]*p1[d]; } siteLogL_[patternIndex] = Math.log(sum); logL += siteLogL_[patternIndex]*sitePattern_.weight[patternIndex]; } return logL; } } pal-1.5.1/src/pal/eval/FastLikelihoodCalculator.java 0000644 0000000 0000000 00000034044 07536661264 021064 0 ustar root root // FastLikelihoodCalculator.java // // (c) 1999-2001 PAL Development Core Team // // This package may be distributed under the // terms of the Lesser GNU General Public License (LGPL) package pal.eval; import pal.tree.*; import pal.alignment.*; import pal.substmodel.*; import pal.datatype.*; import pal.misc.*; import java.util.*; /** * Title: Fast Likelihood CalculatorDescription: A simple implementation of a calculator for conditional probabilites are a leaf (tip), with no ambiguities in the data
*Copyright: Copyright (c) 2003
*Company:
* @author not attributable * @version 1.0 * @note not designed to be serialized */ import pal.substmodel.*; public class SimpleLeafCalculator implements LHCalculator.Leaf{ private final int numberOfStates_; private final int[] patternStateMatchup_; //Only needed for cloning... private final int numberOfPatterns_; //Only needed for cloning... private final int numberOfCategories_; //Only needed for cloning... private final LHCalculator.Generator parent_;//Only needed for cloning... private final double[][][] transitionProbabilitiyStore_; private final ConditionalProbabilityStore conditionalProbabilities_; private final ConditionalProbabilityStore flatConditionalProbabilities_; private double lastDistance_ = -1; private SimpleLeafCalculator(SimpleLeafCalculator toCopy) { this.numberOfStates_ = toCopy.numberOfStates_; this.patternStateMatchup_ = toCopy.patternStateMatchup_; this.numberOfPatterns_ = toCopy.numberOfPatterns_; this.numberOfCategories_ = toCopy.numberOfCategories_; this.parent_ = toCopy.parent_; this.transitionProbabilitiyStore_ = pal.misc.Utils.getCopy(toCopy.transitionProbabilitiyStore_); this.flatConditionalProbabilities_ = createFlat(patternStateMatchup_,numberOfPatterns_,numberOfCategories_,numberOfStates_,parent_); this.conditionalProbabilities_ = createExtended(transitionProbabilitiyStore_, patternStateMatchup_,numberOfPatterns_,numberOfCategories_,numberOfStates_,parent_); this.lastDistance_ = toCopy.lastDistance_; } public SimpleLeafCalculator( int[] patternStateMatchup, int numberOfPatterns, int numberOfStates, int numberOfCategories, LHCalculator.Generator parent ) { this.numberOfStates_ = numberOfStates; this.numberOfCategories_ = numberOfCategories; this.numberOfPatterns_ = numberOfPatterns; this.parent_ = parent; this.patternStateMatchup_ = pal.misc.Utils.getCopy(patternStateMatchup); // StatePatternMatchup matches a state to it's new pattern (is undefined if state does not occur) this.transitionProbabilitiyStore_ = new double[numberOfCategories][numberOfStates][numberOfStates]; this.conditionalProbabilities_ = createExtended(transitionProbabilitiyStore_,patternStateMatchup,numberOfPatterns,numberOfCategories,numberOfStates,parent); this.flatConditionalProbabilities_ = createFlat(patternStateMatchup,numberOfPatterns,numberOfCategories,numberOfStates,parent); } // ==================================== private static final ConditionalProbabilityStore createFlat(int[] patternStateMatchup, int numberOfPatterns, int numberOfCategories, int numberOfStates, LHCalculator.Generator parent ) { ConditionalProbabilityStore flatConditionalProbabilities = parent.createAppropriateConditionalProbabilityStore( true ); final double[] gapStore = new double[numberOfStates]; for(int i = 0 ; i < gapStore.length ; i++) { gapStore[i] = 1; } double[][] stateStuff = new double[numberOfStates][numberOfStates]; for( int i = 0; iDescription: A set of static methods for doing common Likelihood tasks. Also serves as example code for doing likeilihood analysis.
* @author Matthew Goode * @version 1.0 */ import pal.tree.*; import pal.math.*; import pal.alignment.*; import pal.substmodel.SubstitutionModel; import pal.misc.TimeOrderCharacterData; import pal.mep.*; import pal.datatype.*; public final class LikelihoodTool { /** * Calculate the log likelihood of a particular set of phylogenetic data * @param tree The tree with set branch lengths * @param alignment The alignment (sequence names must match tree) * @param model The substitution model to use * @return The log likelihood * @note If the alignment uses IUPACNucleotides and the model uses Nucleotides see getMatchingDataType() */ public final static double calculateLogLikelihood(Tree tree, Alignment alignment, SubstitutionModel model) { GeneralLikelihoodCalculator lc = new GeneralLikelihoodCalculator(alignment,tree,model); return lc.calculateLogLikelihood(); } /** * Optimise the branches of a tree with regard to maximum likelihood, with no constraints on the branchlengths (as for an unrooted tree). The topology is unchanged. * @param tree The tree (remains unchanged) * @param alignment The alignment (sequence names must match tree) * @param model The substitution model to use (is changed if optimisation of the model is choosen) * @param optimiseModel if true the model is also optimised, otherwise just the tree * @return The optimised tree * @see pal.treesearch.optimiseUnrootedFixed() for an equivalient, but potentially faster method. * @note If the alignment uses IUPACNucleotides and the model uses Nucleotides see getMatchingDataType() */ public final static Tree optimiseUnrooted(Tree tree, Alignment alignment, SubstitutionModel model, boolean optimiseModel) { UnconstrainedTree ut = new UnconstrainedTree(TreeTool.getUnrooted(tree)); DataTranslator dt = new DataTranslator(alignment); alignment = dt.toAlignment(MolecularDataType.Utils.getMolecularDataType(model.getDataType()),0); if(optimiseModel) { LikelihoodOptimiser.optimiseCombined(ut, alignment, model, new OrthogonalSearch(), 6, 6); } else { LikelihoodOptimiser.optimiseTree(ut, alignment, model, new OrthogonalSearch(), 6, 6); } return new SimpleTree(ut); } /** * Optimise the branches of a tree with regard to maximum likelihood, with a molecular clock assumption, that is, constrained such that all tips are contemporaneous, the tree is treated as rooted. The topology is unchanged. * @param tree The tree with set branch lengths * @param alignment The alignment (sequence names must match tree) * @param model The substitution model to use * @param optimiseModel if true the model is optimised as well * @return The resulting optimised tree * @note If the alignment uses IUPACNucleotides and the model uses Nucleotides see getMatchingDataType() */ public final static Tree optimiseClockConstrained(Tree tree, Alignment alignment, SubstitutionModel model, boolean optimiseModel) { ClockTree ut = new ClockTree(tree); DataTranslator dt = new DataTranslator(alignment); alignment = dt.toAlignment(MolecularDataType.Utils.getMolecularDataType(model.getDataType()),0); if(optimiseModel) { LikelihoodOptimiser.optimiseCombined(ut, alignment, model, new OrthogonalSearch(), 6, 6); } else { LikelihoodOptimiser.optimiseTree(ut, alignment, model, new OrthogonalSearch(), 6, 6); } return new SimpleTree(ut); } /** * Optimise the branches of a tree with regard to maximum likelihood, with under an assumption of a molecular clock with serially sampled data and a single mutation rate parameter. This is equivalent to the TipDate model. The topology is unchanged. * @param tree The tree with set branch lengths * @param alignment The alignment (sequence names must match tree) * @param model The substitution model to use * @param tocd The sample information object relating sequences to time or order * @param optimiseModel if true the model is optimised as well * @param rateStore storage space for the mutation rate, the initial value is used as the starting rate in the optimisation * @return The resulting optimised tree * @note If the alignment uses IUPACNucleotides and the model uses Nucleotides see getMatchingDataType() */ public final static Tree optimiseSRDT(Tree tree, Alignment alignment, SubstitutionModel model, TimeOrderCharacterData tocd, boolean optimiseModel, double[] rateStore) { ConstantMutationRate cm = new ConstantMutationRate(rateStore[0], tocd.getUnits(),1); DataTranslator dt = new DataTranslator(alignment); alignment = dt.toAlignment(MolecularDataType.Utils.getMolecularDataType(model.getDataType()),0); MutationRateModelTree mt = new MutationRateModelTree( tree,tocd, cm); if(optimiseModel) { LikelihoodOptimiser.optimiseCombined(mt, alignment, model, new OrthogonalSearch(), 6, 6); } else { LikelihoodOptimiser.optimiseTree(mt, alignment, model, new OrthogonalSearch(), 6, 6); } rateStore[0] = cm.getMu(); return new SimpleTree(mt); } /** * Optimise the branches of a tree with regard to maximum likelihood, with under an assumption of a molecular clock with serially sampled data and multiple mutation rate parameters, mu - one for each sampling interval. The topology is unchanged. * @param tree The tree with set branch lengths * @param alignment The alignment (sequence names must match tree) * @param model The substitution model to use * @param tocd The sample information object relating sequences to time or order * @param optimiseModel if true the model is optimised as well * @param rateStore storage space for the mus, the initial values are used as the starting mus in the optimisation * @return The resulting optimised tree * @note If the alignment uses IUPACNucleotides and the model uses Nucleotides see getMatchingDataType() */ public final static Tree optimiseMRDT(Tree tree, Alignment alignment, SubstitutionModel model, TimeOrderCharacterData tocd, boolean optimiseModel, double[] rateStore) { SteppedMutationRate smr = new SteppedMutationRate(pal.misc.Utils.getCopy(rateStore), tocd); DataTranslator dt = new DataTranslator(alignment); alignment = dt.toAlignment(MolecularDataType.Utils.getMolecularDataType(model.getDataType()),0); MutationRateModelTree mt = new MutationRateModelTree( tree,tocd, smr); if(optimiseModel) { LikelihoodOptimiser.optimiseCombined(mt, alignment, model, new OrthogonalSearch(), 6, 6); } else { LikelihoodOptimiser.optimiseTree(mt, alignment, model, new OrthogonalSearch(), 6, 6); } smr.getMus(rateStore); return new SimpleTree(mt); } /** * Optimise the branches of a tree with regard to maximum likelihood, with under an assumption of a molecular clock with serially sampled data and multiple mutation rate parameters, mu, over general time intervals. The topology is unchanged. * @param tree The tree with set branch lengths * @param alignment The alignment (sequence names must match tree) * @param model The substitution model to use * @param tocd The sample information object relating sequences to time or order * @param optimiseModel if true the model is optimised as well * @param rateChangeTimes the times (as related to the sample information) of when a new mu is used (should be of length mus.length -1 ) * @param rateStore storage space for the mus, the initial values are used as the starting mus in the optimisation * @return The resulting optimised tree * @note If the alignment uses IUPACNucleotides and the model uses Nucleotides see getMatchingDataType() */ public final static Tree optimiseMRDT(Tree tree, Alignment alignment, SubstitutionModel model, TimeOrderCharacterData tocd, boolean optimiseModel, double[] rateChangeTimes, double[] rateStore) { DataTranslator dt = new DataTranslator(alignment); alignment = dt.toAlignment(MolecularDataType.Utils.getMolecularDataType(model.getDataType()),0); SteppedMutationRate smr = new SteppedMutationRate(pal.misc.Utils.getCopy(rateStore), pal.misc.Utils.getCopy(rateChangeTimes), tocd.getUnits(),false,tocd.getSuggestedMaximumMutationRate()*2); MutationRateModelTree mt = new MutationRateModelTree( tree,tocd, smr); if(optimiseModel) { LikelihoodOptimiser.optimiseCombined(mt, alignment, model, new OrthogonalSearch(), 6, 6); } else { LikelihoodOptimiser.optimiseTree(mt, alignment, model, new OrthogonalSearch(), 6, 6); } smr.getMus(rateStore); return new SimpleTree(mt); } /** * Creates a new alignment that has a compatible data type with a substution model (needed for likelihood stuff) * @param alignment The base alignment * @param model The substitution model that will be used with the alignment data * @return An appropriately converted alignment * @note this is also neccessary if the alignment uses IUPACNucleotides and the model is Nucleotides */ public static final Alignment getMatchingDataType(Alignment alignment, SubstitutionModel model) { DataTranslator dt = new DataTranslator(alignment); return dt.toAlignment(MolecularDataType.Utils.getMolecularDataType(model.getDataType()),0); } } pal-1.5.1/src/pal/eval/LHCalculator.java 0000644 0000000 0000000 00000041330 10141731414 016437 0 ustar root root // LHCalculator.java // // (c) 1999-2003 PAL Development Core Team // // This package may be distributed under the // terms of the Lesser GNU General Public License (LGPL) package pal.eval; /** *Title: LHCalculator
*Description: An LHCalculator object must be treated as a stateful, single threaded object that can be used * for calculating components in an overall likelihood calculation.
*History
*
Title: LikelihoodOptimiser
*Description: A strange tool for optimizing the likelihood
* @author Matthew Goode * @version 1.0 */ import pal.misc.Parameterized; import pal.tree.Tree; import pal.tree.ParameterizedTree; import pal.alignment.Alignment; import pal.substmodel.SubstitutionModel; import pal.math.*; public class LikelihoodOptimiser { private final Function function_; private final Tree tree_; private final Alignment alignment_; private final SubstitutionModel model_; private double[] argumentStore_ = null; public LikelihoodOptimiser(Tree tree, Alignment alignment, SubstitutionModel model) { this.function_ = new Function(tree,alignment,model); this.tree_ = tree; this.alignment_ = alignment; this.model_ = model; } private final double[] setup(Parameterized parameters) { function_.setParameters(parameters); argumentStore_ = function_.getCurrentArgumentStore(argumentStore_); return argumentStore_; } public double optimiseLogLikelihood(Parameterized parameters, MultivariateMinimum minimiser, int fxFracDigits, int xFracDigits, MinimiserMonitor monitor) { double result = -minimiser.findMinimum(function_,setup(parameters),fxFracDigits, xFracDigits,monitor); return result; } public double optimiseLogLikelihood(Parameterized parameters, MultivariateMinimum minimiser, int fxFracDigits, int xFracDigits) { double result = -minimiser.findMinimum(function_,setup(parameters),fxFracDigits, xFracDigits); return result; } /** * Optimise parameters to acheive maximum likelihood using a combined stategy. That is, model and tree are optimised concurrently. * @param tree The tree to be optimised (will be altered by optimisation) * @param alignment The alignment related to tree * @param model The substitution model to be optimised (will be altered by optimisation) * @param fxFracDigits The number of decimal placess to stabilise to in the log likelihood * @param xFracDigits The number of decimal placess to stabilise to in the model/tree parameters * @param minimiser The MultivariateMinimum object that is used for minimising * @param monitor A minimiser monitor to monitor progress * @return The maximal log likelihood found */ public static final double optimiseCombined(ParameterizedTree tree, Alignment alignment, SubstitutionModel model, MultivariateMinimum minimiser, int fxFracDigits, int xFracDigits, MinimiserMonitor monitor) { final LikelihoodOptimiser lo = new LikelihoodOptimiser(tree,alignment,model); return lo.optimiseLogLikelihood(Parameterized.Utils.combine(tree,model),minimiser,fxFracDigits,xFracDigits,monitor); } /** * Optimise parameters to acheive maximum likelihood using a combined stategy. That is, model and tree are optimised concurrently. * @param tree The tree to be optimised (will be altered by optimisation) * @param alignment The alignment related to tree * @param model The substitution model to be optimised (will be altered by optimisation) * @param fxFracDigits The number of decimal placess to stabilise to in the log likelihood * @param xFracDigits The number of decimal placess to stabilise to in the model/tree parameters * @param minimiser The MultivariateMinimum object that is used for minimising * @return The maximal log likelihood found */ public static final double optimiseCombined(ParameterizedTree tree, Alignment alignment, SubstitutionModel model, MultivariateMinimum minimiser, int fxFracDigits, int xFracDigits) { final LikelihoodOptimiser lo = new LikelihoodOptimiser(tree,alignment,model); return lo.optimiseLogLikelihood(Parameterized.Utils.combine(tree,model),minimiser,fxFracDigits,xFracDigits); } /** * Optimise parameters to acheive maximum likelihood using an alternating stategy. That is first the model is optimised, than the tree branch lengths, then the model, then the tree, and so on until convergence. * @param tree The tree to be optimised (will be altered by optimisation) * @param alignment The alignment related to tree * @param model The substitution model to be optimised (will be altered by optimisation) * @param fxFracDigits The number of decimal placess to stabilise to in the log likelihood * @param xFracDigits The number of decimal placess to stabilise to in the model/tree parameters * @param minimiser The MultivariateMinimum object that is used for minimising * @return The maximal log likelihood found */ public static final double optimiseAlternate(ParameterizedTree tree, Alignment alignment, SubstitutionModel model, MultivariateMinimum minimiser, int fxFracDigits, int xFracDigits) { return optimiseAlternate(tree,alignment,model,minimiser,fxFracDigits,xFracDigits,null); } /** * Optimise parameters to acheive maximum likelihood using an alternating stategy. That is first the model is optimised, than the tree branch lengths, then the model, then the tree, and so on until convergence. * @param tree The tree to be optimised (will be altered by optimisation) * @param alignment The alignment related to tree * @param model The substitution model to be optimised (will be altered by optimisation) * @param fxFracDigits The number of decimal placess to stabilise to in the log likelihood * @param xFracDigits The number of decimal placess to stabilise to in the model/tree parameters * @param minimiser The MultivariateMinimum object that is used for minimising * @param monitor A minimiser monitor to monitor progress * @return The maximal log likelihood found */ public static final double optimiseAlternate(ParameterizedTree tree, Alignment alignment, SubstitutionModel model, MultivariateMinimum minimiser, int fxFracDigits, int xFracDigits, MinimiserMonitor monitor) { final LikelihoodOptimiser lo = new LikelihoodOptimiser(tree,alignment,model); double epsilon = generateEpsilon(fxFracDigits); double lastResult = 0; double result = 0; int round = 0; while(true) { //Optimise Model result = optimise(lo, model,minimiser,fxFracDigits,xFracDigits,monitor); //Optimiser tree result = optimise(lo, tree,minimiser,fxFracDigits,xFracDigits,monitor); if(round>0) { if( lastResult>result ) { break; } if( result-lastResultDescription: A container class for various bits of data relating to * the conditional likelihood. Things stored include the conditional likelihood, * an scale factors and whether the current conditional likelihoods were created * from cached data.
* @author Matthew Goode * @version 1.0 */ public final class ConditionalProbabilityStore implements java.io.Serializable { private final int numberOfCategories_; private final int numberOfStates_; private final double[][][] store_; private int patternCapacity_; private final ExtraProcessor extraProcessor_; private boolean isBasedOnCachedData_ = false; private boolean fix_ = false; private ConditionalProbabilityStore(ConditionalProbabilityStore toCopy) { this.numberOfCategories_ = toCopy.numberOfCategories_; this.numberOfStates_ = toCopy.numberOfStates_; this.store_ = pal.misc.Utils.getCopy(toCopy.store_); this.patternCapacity_ = toCopy.patternCapacity_; this.extraProcessor_ = (toCopy.extraProcessor_ == null ? null : toCopy.extraProcessor_.getCopy()); this.isBasedOnCachedData_ = toCopy.isBasedOnCachedData_; this.fix_ = toCopy.fix_; } public ConditionalProbabilityStore(int numberOfCategories, int numberOfStates) { this(numberOfCategories,numberOfStates,null); } public ConditionalProbabilityStore(int numberOfCategories, int numberOfStates, ExtraProcessor extraProcessor) { this.numberOfCategories_ = numberOfCategories; this.numberOfStates_ = numberOfStates; this.store_ = new double[numberOfCategories][][]; this.patternCapacity_ = 0; this.extraProcessor_ = extraProcessor; if(extraProcessor_!=null) { this.extraProcessor_.setParent(this); this.extraProcessor_.setNewNumberOfPatterns( 0 ); } } /** * Cloning * @return a copy of this conditional probability store */ public final ConditionalProbabilityStore getCopy() { return new ConditionalProbabilityStore(this); } public final boolean isHasExtraProcessor() { return extraProcessor_!=null; } public final ExtraProcessor getExtraProcessor() { return extraProcessor_; } /** * Will check the current allocation to see if it can accomodate the requested number * of patterns. If not, new arrays are allocated and old data is lost. * @param numberOfPatterns */ private final void ensureSize(int numberOfPatterns, boolean createStateArray) { if(numberOfPatterns>patternCapacity_) { if(fix_) { throw new IllegalArgumentException("Cannot resize to accomodate "+numberOfPatterns+" patterns (store has been fixed)"); } if(createStateArray) { for( int i = 0; iDescription: A simpler LHCalculator with unrolled loops for four state data types (eg Nucleotides)
* @author Matthew Goode * @version 1.0 */ import pal.datatype.*; import pal.substmodel.*; public final class FastFourStateLHCalculator implements LHCalculator { private final static int FOUR_STATES = 4; private final static void calculateSingleExtendedIndirectImpl( double distance, SubstitutionModel model, int numberOfPatterns, ConditionalProbabilityStore baseConditionalProbabilities, ConditionalProbabilityStore resultConditionalProbabilities, double[][][] transitionProbabilityStore, int numberOfCategories ) { model.getTransitionProbabilities( distance, transitionProbabilityStore ); double[][][] baseStoreValues = baseConditionalProbabilities.getCurrentConditionalProbabilities(); double[][][] resultStoreValues = baseConditionalProbabilities.getConditionalProbabilityAccess(numberOfPatterns,false); for( int category = 0; categoryDescription:
*Copyright: Copyright (c) 2003
*Company:
* @author not attributable * @version 1.0 */ import pal.datatype.*; import pal.substmodel.*; public class SimpleLHCalculator implements LHCalculator { private static final SimpleFactory FACTORY_INSTANCE = new SimpleFactory(); private final static void calculateSingleExtendedIndirectImpl( double distance, SubstitutionModel model, int numberOfPatterns, ConditionalProbabilityStore baseConditionalProbabilities, ConditionalProbabilityStore resultConditionalProbabilities, double[][][] transitionProbabilityStore, int numberOfCategories, int numberOfStates ) { model.getTransitionProbabilities( distance, transitionProbabilityStore ); double[][][] resultStoreValues = resultConditionalProbabilities.getConditionalProbabilityAccess( numberOfPatterns, false ); double[][][] baseStoreValues = baseConditionalProbabilities.getCurrentConditionalProbabilities(); for( int category = 0; categoryDescription: An interface to objects that can be used for calculating likelihood estimates when a molecular clock is assumed (and therefore knowledge of the relative temporal order of events)
* @author Matthew Goode * @version 1.0 *History
*
Title: SiteDetails (was Posteriors)
*Description: Access for site based information that are calculated post ML optimisation
* @author Matthew Goode * @version 1.0 */ import pal.substmodel.*; public interface SiteDetails { public SubstitutionModel getRelatedModel(); public double[] getSitePosteriors(int site); /** * Get the likelihoods for each site (not the log likelihoods) * @return a double array of likelihoods matching each site */ public double[] getSiteLikelihoods(); /** * Get the likelihoods for each site (logged) * @return a double array of log likelihoods matching each site */ public double[] getSiteLogLikelihoods(); // -=-=-==--==- public static final class Utils { /** * Create a Postriors object * @param categoryPatternConditionalProbabilities An array arranged [category][pattern] that holds the conditional probabilities for each category at each site * @param isLoggedConditionals should be true if the conditional probabilities are stored as logged values, false if not * @param model the related substitution models * @param numberOfPatterns the number of patterns * @param sitePatternMatchup an array that identifies what pattern is to used at which site * @param numberOfSites the number of sites * @param siteLikelihoods the site likelihood (unlogged) at each site * @return an appropriate Posteriors object */ public static final SiteDetails create(double[][] categoryPatternConditionalProbabilities, boolean isLoggedConditionals, SubstitutionModel model, int numberOfPatterns, int[] sitePatternMatchup, int numberOfSites, double[] siteLikelihoods) { return new SimpleSiteDetails(categoryPatternConditionalProbabilities,isLoggedConditionals, model, numberOfPatterns, sitePatternMatchup,numberOfSites,siteLikelihoods); } /** * Create a Postriors object with no related substitution model * @param categoryPatternConditionalProbabilities An array arranged [category][pattern] that holds the conditional probabilities for each category at each site * @param isLoggedConditionals should be true if the conditional probabilities are stored as logged values, false if not * @param numberOfPatterns the number of patterns * @param sitePatternMatchup an array that identifies what pattern is to used at which site * @param numberOfSites the number of sites * @param siteLikelihoods the site likelihood (unlogged) at each site * @return an appropriate Posteriors object */ public static final SiteDetails create(double[][] categoryPatternConditionalProbabilities, boolean isLoggedConditionals,int numberOfPatterns, int[] sitePatternMatchup, int numberOfSites, double[] siteLikelihoods) { return new SimpleSiteDetails(categoryPatternConditionalProbabilities,isLoggedConditionals, numberOfPatterns, sitePatternMatchup,numberOfSites,siteLikelihoods); } //-=-=-=-=-= private final static class SimpleSiteDetails implements SiteDetails { private final double[][] categoryPatternConditionalProbabilities_; private final double[][] patternPosteriors_; private final double[] siteLikelihoods_; private final double[] siteLogLikelihoods_; private final int[] sitePatternMatchup_; private final SubstitutionModel model_; private final int numberOfSites_; public SimpleSiteDetails( double[][] categoryPatternConditionalProbabilities, boolean isLoggedConditionals, int numberOfPatterns, int[] sitePatternMatchup, int numberOfSites, double[] siteLikelihoods ) { this(categoryPatternConditionalProbabilities,isLoggedConditionals, null,numberOfPatterns,sitePatternMatchup, numberOfSites, siteLikelihoods); } public SimpleSiteDetails( double[][] categoryPatternConditionalProbabilities, boolean isLoggedConditionals, SubstitutionModel model, int numberOfPatterns, int[] sitePatternMatchup, int numberOfSites, double[] siteLikelihoods ) { final int numberOfCategories = model.getNumberOfTransitionCategories(); this.siteLikelihoods_ = pal.misc.Utils.getCopy(siteLikelihoods); this.siteLogLikelihoods_ = new double[numberOfSites]; double llh = 0; for(int i = 0 ; i < numberOfSites ; i++) { this.siteLogLikelihoods_[i] = Math.log(this.siteLikelihoods_[i]); llh+=this.siteLogLikelihoods_[i]; } System.out.println("Total:"+llh); if( isLoggedConditionals ) { this.categoryPatternConditionalProbabilities_ = convertLogged( categoryPatternConditionalProbabilities, numberOfCategories, numberOfPatterns ); } else { this.categoryPatternConditionalProbabilities_ = pal.misc.Utils.getCopy( categoryPatternConditionalProbabilities ); } this.numberOfSites_ = numberOfSites; this.sitePatternMatchup_ = pal.misc.Utils.getCopy( sitePatternMatchup ); this.patternPosteriors_ = new double[numberOfPatterns][numberOfCategories]; for( int p = 0; p