| libhmsbeagle/beagle.h(3) | BEAGLE | libhmsbeagle/beagle.h(3) |
libhmsbeagle/beagle.h - This file documents the API as well as header for the Broad-platform Evolutionary Analysis General Likelihood Evaluator.
#include 'libhmsbeagle/platform.h'
struct BeagleInstanceDetails
Information about a specific instance. struct BeagleResource
Description of a hardware resource. struct BeagleResourceList
List of hardware resources. struct BeagleBenchmarkedResource
Description of a benchmarked hardware resource. struct
BeagleBenchmarkedResourceList
Ordered list of benchmarked hardware resources, from fastest to slowest.
struct BeagleOperation
A list of integer indices which specify a partial likelihoods operation.
struct BeagleOperationByPartition
A list of integer indices which specify a partial likelihoods operation for a
partitioned analysis.
enum BeagleReturnCodes { BEAGLE_SUCCESS = 0,
BEAGLE_ERROR_GENERAL = -1, BEAGLE_ERROR_OUT_OF_MEMORY = -2,
BEAGLE_ERROR_UNIDENTIFIED_EXCEPTION = -3,
BEAGLE_ERROR_UNINITIALIZED_INSTANCE = -4,
BEAGLE_ERROR_OUT_OF_RANGE = -5, BEAGLE_ERROR_NO_RESOURCE = -6,
BEAGLE_ERROR_NO_IMPLEMENTATION = -7,
BEAGLE_ERROR_FLOATING_POINT = -8 }
Error return codes. enum BeagleFlags {
BEAGLE_FLAG_PRECISION_SINGLE = 1 << 0,
BEAGLE_FLAG_PRECISION_DOUBLE = 1 << 1,
BEAGLE_FLAG_COMPUTATION_SYNCH = 1 << 2,
BEAGLE_FLAG_COMPUTATION_ASYNCH = 1 << 3,
BEAGLE_FLAG_EIGEN_REAL = 1 << 4,
BEAGLE_FLAG_EIGEN_COMPLEX = 1 << 5,
BEAGLE_FLAG_SCALING_MANUAL = 1 << 6,
BEAGLE_FLAG_SCALING_AUTO = 1 << 7,
BEAGLE_FLAG_SCALING_ALWAYS = 1 << 8,
BEAGLE_FLAG_SCALING_DYNAMIC = 1 << 25,
BEAGLE_FLAG_SCALERS_RAW = 1 << 9,
BEAGLE_FLAG_SCALERS_LOG = 1 << 10,
BEAGLE_FLAG_INVEVEC_STANDARD = 1 << 20,
BEAGLE_FLAG_INVEVEC_TRANSPOSED = 1 << 21,
BEAGLE_FLAG_VECTOR_SSE = 1 << 11, BEAGLE_FLAG_VECTOR_AVX
= 1 << 24, BEAGLE_FLAG_VECTOR_NONE = 1 << 12,
BEAGLE_FLAG_THREADING_CPP = 1 << 30,
BEAGLE_FLAG_THREADING_OPENMP = 1 << 13,
BEAGLE_FLAG_THREADING_NONE = 1 << 14,
BEAGLE_FLAG_PROCESSOR_CPU = 1 << 15,
BEAGLE_FLAG_PROCESSOR_GPU = 1 << 16,
BEAGLE_FLAG_PROCESSOR_FPGA = 1 << 17,
BEAGLE_FLAG_PROCESSOR_CELL = 1 << 18,
BEAGLE_FLAG_PROCESSOR_PHI = 1 << 19,
BEAGLE_FLAG_PROCESSOR_OTHER = 1 << 26,
BEAGLE_FLAG_FRAMEWORK_CUDA = 1 << 22,
BEAGLE_FLAG_FRAMEWORK_OPENCL = 1 << 23,
BEAGLE_FLAG_FRAMEWORK_CPU = 1 << 27,
BEAGLE_FLAG_PARALLELOPS_STREAMS = 1 << 28,
BEAGLE_FLAG_PARALLELOPS_GRID = 1 << 29 }
Hardware and implementation capability flags. enum BeagleBenchmarkFlags
{ BEAGLE_BENCHFLAG_SCALING_NONE = 1 << 0,
BEAGLE_BENCHFLAG_SCALING_ALWAYS = 1 << 1,
BEAGLE_BENCHFLAG_SCALING_DYNAMIC = 1 << 2 }
Benchmarking mode flags for resource performance evaluation with
beagleGetOrderedResourceList. enum BeagleOpCodes {
BEAGLE_OP_COUNT = 7, BEAGLE_PARTITION_OP_COUNT = 9,
BEAGLE_OP_NONE = -1 }
Operation codes.
BEAGLE_DLLEXPORT const char * beagleGetVersion (void)
Get version. BEAGLE_DLLEXPORT const char * beagleGetCitation (void)
Get citation. BEAGLE_DLLEXPORT BeagleResourceList *
beagleGetResourceList (void)
Get list of hardware resources. BEAGLE_DLLEXPORT
BeagleBenchmarkedResourceList *
beagleGetBenchmarkedResourceList (int tipCount, int
compactBufferCount, int stateCount, int patternCount, int categoryCount, int
*resourceList, int resourceCount, long preferenceFlags, long
requirementFlags, int eigenModelCount, int partitionCount, int
calculateDerivatives, long benchmarkFlags)
Get a benchmarked list of hardware resources for the given analysis
parameters. BEAGLE_DLLEXPORT int beagleCreateInstance (int tipCount,
int partialsBufferCount, int compactBufferCount, int stateCount, int
patternCount, int eigenBufferCount, int matrixBufferCount, int
categoryCount, int scaleBufferCount, int *resourceList, int resourceCount,
long preferenceFlags, long requirementFlags, BeagleInstanceDetails
*returnInfo)
Create a single instance. BEAGLE_DLLEXPORT int beagleFinalizeInstance
(int instance)
Finalize this instance. BEAGLE_DLLEXPORT int beagleFinalize (void)
Finalize the library. BEAGLE_DLLEXPORT int beagleSetCPUThreadCount (int
instance, int threadCount)
Set number of threads for native CPU implementation. BEAGLE_DLLEXPORT int
beagleSetTipStates (int instance, int tipIndex, const int *inStates)
Set the compact state representation for tip node. BEAGLE_DLLEXPORT int
beagleSetTipPartials (int instance, int tipIndex, const double
*inPartials)
Set an instance partials buffer for tip node. BEAGLE_DLLEXPORT int
beagleSetPartials (int instance, int bufferIndex, const double
*inPartials)
Set an instance partials buffer. BEAGLE_DLLEXPORT int beagleGetPartials
(int instance, int bufferIndex, int scaleIndex, double *outPartials)
Get partials from an instance buffer. BEAGLE_DLLEXPORT int
beagleSetEigenDecomposition (int instance, int eigenIndex, const
double *inEigenVectors, const double *inInverseEigenVectors, const double
*inEigenValues)
Set an eigen-decomposition buffer. BEAGLE_DLLEXPORT int
beagleSetStateFrequencies (int instance, int stateFrequenciesIndex,
const double *inStateFrequencies)
Set a state frequency buffer. BEAGLE_DLLEXPORT int
beagleSetCategoryWeights (int instance, int categoryWeightsIndex,
const double *inCategoryWeights)
Set a category weights buffer. BEAGLE_DLLEXPORT int
beagleSetCategoryRates (int instance, const double *inCategoryRates)
Set the default category rates buffer. BEAGLE_DLLEXPORT int
beagleSetCategoryRatesWithIndex (int instance, int
categoryRatesIndex, const double *inCategoryRates)
Set a category rates buffer. BEAGLE_DLLEXPORT int
beagleSetPatternWeights (int instance, const double
*inPatternWeights)
Set pattern weights. BEAGLE_DLLEXPORT int beagleSetPatternPartitions
(int instance, int partitionCount, const int *inPatternPartitions)
Set pattern partition assignments. BEAGLE_DLLEXPORT int
beagleConvolveTransitionMatrices (int instance, const int
*firstIndices, const int *secondIndices, const int *resultIndices, int
matrixCount)
Set partitions by pattern weight. BEAGLE_DLLEXPORT int
beagleUpdateTransitionMatrices (int instance, int eigenIndex, const
int *probabilityIndices, const int *firstDerivativeIndices, const int
*secondDerivativeIndices, const double *edgeLengths, int count)
Calculate a list of transition probability matrices. BEAGLE_DLLEXPORT int
beagleUpdateTransitionMatricesWithMultipleModels (int instance, const
int *eigenIndices, const int *categoryRateIndices, const int
*probabilityIndices, const int *firstDerivativeIndices, const int
*secondDerivativeIndices, const double *edgeLengths, int count)
Calculate a list of transition probability matrices with multiple models.
BEAGLE_DLLEXPORT int beagleSetTransitionMatrix (int instance, int
matrixIndex, const double *inMatrix, double paddedValue)
Set a finite-time transition probability matrix. BEAGLE_DLLEXPORT int
beagleGetTransitionMatrix (int instance, int matrixIndex, double
*outMatrix)
Get a finite-time transition probability matrix. BEAGLE_DLLEXPORT int
beagleSetTransitionMatrices (int instance, const int *matrixIndices,
const double *inMatrices, const double *paddedValues, int count)
Set multiple transition matrices. BEAGLE_DLLEXPORT int
beagleUpdatePartials (const int instance, const
BeagleOperation *operations, int operationCount, int
cumulativeScaleIndex)
Calculate or queue for calculation partials using a list of operations.
BEAGLE_DLLEXPORT int beagleUpdatePartialsByPartition (const int
instance, const BeagleOperationByPartition *operations, int
operationCount)
Calculate or queue for calculation partials using a list of partition
operations. BEAGLE_DLLEXPORT int beagleWaitForPartials (const int
instance, const int *destinationPartials, int destinationPartialsCount)
Block until all calculations that write to the specified partials have
completed. BEAGLE_DLLEXPORT int beagleAccumulateScaleFactors (int
instance, const int *scaleIndices, int count, int cumulativeScaleIndex)
Accumulate scale factors. BEAGLE_DLLEXPORT int
beagleAccumulateScaleFactorsByPartition (int instance, const int
*scaleIndices, int count, int cumulativeScaleIndex, int partitionIndex)
Accumulate scale factors by partition. BEAGLE_DLLEXPORT int
beagleRemoveScaleFactors (int instance, const int *scaleIndices, int
count, int cumulativeScaleIndex)
Remove scale factors. BEAGLE_DLLEXPORT int
beagleRemoveScaleFactorsByPartition (int instance, const int
*scaleIndices, int count, int cumulativeScaleIndex, int partitionIndex)
Remove scale factors by partition. BEAGLE_DLLEXPORT int
beagleResetScaleFactors (int instance, int cumulativeScaleIndex)
Reset scalefactors. BEAGLE_DLLEXPORT int
beagleResetScaleFactorsByPartition (int instance, int
cumulativeScaleIndex, int partitionIndex)
Reset scalefactors by partition. BEAGLE_DLLEXPORT int
beagleCopyScaleFactors (int instance, int destScalingIndex, int
srcScalingIndex)
Copy scale factors. BEAGLE_DLLEXPORT int beagleGetScaleFactors (int
instance, int srcScalingIndex, double *outScaleFactors)
Get scale factors. BEAGLE_DLLEXPORT int
beagleCalculateRootLogLikelihoods (int instance, const int
*bufferIndices, const int *categoryWeightsIndices, const int
*stateFrequenciesIndices, const int *cumulativeScaleIndices, int count,
double *outSumLogLikelihood)
Calculate site log likelihoods at a root node. BEAGLE_DLLEXPORT int
beagleCalculateRootLogLikelihoodsByPartition (int instance, const int
*bufferIndices, const int *categoryWeightsIndices, const int
*stateFrequenciesIndices, const int *cumulativeScaleIndices, const int
*partitionIndices, int partitionCount, int count, double
*outSumLogLikelihoodByPartition, double *outSumLogLikelihood)
Calculate site log likelihoods at a root node with per partition buffers.
BEAGLE_DLLEXPORT int beagleCalculateEdgeLogLikelihoods (int instance,
const int *parentBufferIndices, const int *childBufferIndices, const int
*probabilityIndices, const int *firstDerivativeIndices, const int
*secondDerivativeIndices, const int *categoryWeightsIndices, const int
*stateFrequenciesIndices, const int *cumulativeScaleIndices, int count,
double *outSumLogLikelihood, double *outSumFirstDerivative, double
*outSumSecondDerivative)
Calculate site log likelihoods and derivatives along an edge. BEAGLE_DLLEXPORT
int beagleCalculateEdgeLogLikelihoodsByPartition (int instance, const
int *parentBufferIndices, const int *childBufferIndices, const int
*probabilityIndices, const int *firstDerivativeIndices, const int
*secondDerivativeIndices, const int *categoryWeightsIndices, const int
*stateFrequenciesIndices, const int *cumulativeScaleIndices, const int
*partitionIndices, int partitionCount, int count, double
*outSumLogLikelihoodByPartition, double *outSumLogLikelihood, double
*outSumFirstDerivativeByPartition, double *outSumFirstDerivative, double
*outSumSecondDerivativeByPartition, double *outSumSecondDerivative)
Calculate multiple site log likelihoods and derivatives along an edge with per
partition buffers. BEAGLE_DLLEXPORT int beagleGetLogLikelihood (int
instance, double *outSumLogLikelihood)
Returns log likelihood sum and subsequent to an asynchronous integration call.
BEAGLE_DLLEXPORT int beagleGetDerivatives (int instance, double
*outSumFirstDerivative, double *outSumSecondDerivative)
Returns derivative sums subsequent to an asynchronous integration call.
BEAGLE_DLLEXPORT int beagleGetSiteLogLikelihoods (int instance,
double *outLogLikelihoods)
Get site log likelihoods for last beagleCalculateRootLogLikelihoods or
beagleCalculateEdgeLogLikelihoods call. BEAGLE_DLLEXPORT int
beagleGetSiteDerivatives (int instance, double *outFirstDerivatives,
double *outSecondDerivatives)
Get site derivatives for last beagleCalculateEdgeLogLikelihoods call.
This file documents the API as well as header for the Broad-platform Evolutionary Analysis General Likelihood Evaluator.
Copyright 2009-2013 Phylogenetic Likelihood Working Group
This file is part of BEAGLE.
BEAGLE is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
BEAGLE is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along with BEAGLE. If not, see http://www.gnu.org/licenses/.
KEY CONCEPTS
The key to BEAGLE performance lies in delivering fine-scale parallelization while minimizing data transfer and memory copy overhead. To accomplish this, the library lacks the concept of data structure for a tree, in spite of the intended use for phylogenetic analysis. Instead, BEAGLE acts directly on flexibly indexed data storage (called buffers) for observed character states and partial likelihoods. The client program can set the input buffers to reflect the data and can calculate the likelihood of a particular phylogeny by invoking likelihood calculations on the appropriate input and output buffers in the correct order. Because of this design simplicity, the library can support many different tree inference algorithms and likelihood calculation on a variety of models. Arbitrary numbers of states can be used, as can nonreversible substitution matrices via complex eigen decompositions, and mixture models with multiple rate categories and/or multiple eigen decompositions. Finally, BEAGLE application programming interface (API) calls can be asynchronous, allowing the calling program to implement other coarse-scale parallelization schemes such as evaluating independent genes or running concurrent Markov chains.
USAGE
To use the library, a client program first creates an instance of BEAGLE by calling beagleCreateInstance; multiple instances per client are possible and encouraged. All additional functions are called with a reference to this instance. The client program can optionally request that an instance run on certain hardware (e.g., a GPU) or have particular features (e.g., double-precision math). Next, the client program must specify the data dimensions and specify key aspects of the phylogenetic model. Character state data are then loaded and can be in the form of discrete observed states or partial likelihoods for ambiguous characters. The observed data are usually unchanging and loaded only once at the start to minimize memory copy overhead. The character data can be compressed into unique “site patterns” and associated weights for each. The parameters of the substitution process can then be specified, including the equilibrium state frequencies, the rates for one or more substitution rate categories and their weights, and finally, the eigen decomposition for the substitution process.
In order to calculate the likelihood of a particular tree, the client program then specifies a series of integration operations that correspond to steps in Felsenstein’s algorithm. Finite-time transition probabilities for each edge are loaded directly if considering a nondiagonalizable model or calculated in parallel from the eigen decomposition and edge lengths specified. This is performed within BEAGLE’s memory space to minimize data transfers. A single function call will then request one or more integration operations to calculate partial likelihoods over some or all nodes. The operations are performed in the order they are provided, typically dictated by a postorder traversal of the tree topology. The client needs only specify nodes for which the partial likelihoods need updating, but it is up to the calling software to keep track of these dependencies. The final step in evaluating the phylogenetic model is done using an API call that yields a single log likelihood for the model given the data.
Aspects of the BEAGLE API design support both maximum likelihood (ML) and Bayesian phylogenetic tree inference. For ML inference, API calls can calculate first and second derivatives of the likelihood with respect to the lengths of edges (branches). In both cases, BEAGLE provides the ability to cache and reuse previously computed partial likelihood results, which can yield a tremendous speedup over recomputing the entire likelihood every time a new phylogenetic model is evaluated.
Author
Daniel Ayres
Peter Beerli
Michael Cummings
Aaron Darling
Mark Holder
John Huelsenbeck
Paul Lewis
Michael Ott
Andrew Rambaut
Fredrik Ronquist
Marc Suchard
David Swofford
Derrick Zwickl
Benchmarking mode flags for resource performance evaluation with beagleGetOrderedResourceList.
This enumerates all possible benchmarking mode flags. Each mode is a bit in a 'long'
Enumerator
Hardware and implementation capability flags.
This enumerates all possible hardware and implementation capability flags. Each capability is a bit in a 'long'
Enumerator
Operation codes.
This enumerates all possible BEAGLE operation codes.
Enumerator
Error return codes.
This enumerates all possible BEAGLE return codes. Error codes are always negative.
Enumerator
Accumulate scale factors. This function adds (log) scale factors from a list of scaleBuffers to a cumulative scale buffer. It is used to calculate the marginal scaling at a specific node for each site.
Parameters
Accumulate scale factors by partition. This function adds (log) scale factors from a list of scaleBuffers to a cumulative scale buffer. It is used to calculate the marginal scaling at a specific node for each site.
Parameters
Calculate site log likelihoods and derivatives along an edge. This function integrates a list of partials at a parent and child node with respect to a set of partials-weights and state frequencies to return the log likelihood and first and second derivative sums
Parameters
Returns
Calculate multiple site log likelihoods and derivatives along an edge with per partition buffers. This function integrates lists of partials at a parent and child node with respect to a set of partials-weights and state frequencies to return the log likelihood and first and second derivative sums
Parameters
Returns
Calculate site log likelihoods at a root node. This function integrates a list of partials at a node with respect to a set of partials-weights and state frequencies to return the log likelihood sum
Parameters
Returns
Calculate site log likelihoods at a root node with per partition buffers. This function integrates lists of partials at a node with respect to a set of partials-weights and state frequencies to return the log likelihood sums
Parameters
Returns
Set partitions by pattern weight. This function defines partitions by setting their vectors of pattern-weights for an instance. It should be called after beagleSetTipPartials or beagleSetTipStates.
Parameters
Returns
Convolve lists of transition probability matrices
This function convolves two lists of transition probability matrices.
Parameters
Copy scale factors. This function copies scale factors from one buffer to another.
Parameters
Create a single instance. This function creates a single instance of the BEAGLE library and can be called multiple times to create multiple data partition instances each returning a unique identifier.
Parameters
Returns
Finalize the library. This function finalizes the library and releases all allocated memory. This function is automatically called under GNU C via attribute ((destructor)).
Returns
Finalize this instance. This function finalizes the instance by releasing allocated memory
Parameters
Returns
Get a benchmarked list of hardware resources for the given analysis parameters. This function returns a pointer to a BeagleBenchmarkedResourceList struct, which includes a BeagleBenchmarkedResource array describing the available hardware resources with benchmark times and CPU performance ratios for each resource. Resources are benchmarked with the given analysis parameters and the array is ordered from fastest to slowest. If there is an error the function returns NULL.
Parameters
Returns
Get citation. This function returns a pointer to a string describing the version of the library and how to cite it.
Returns
Returns derivative sums subsequent to an asynchronous integration call. This function is optional and only has to be called by clients that use the non-blocking asynchronous computation mode (BEAGLE_FLAG_COMPUTATION_ASYNCH).
If used, this function must be called after a beagleCalculateEdgeLogLikelihoods call. The library will block until the derivatiives have been calculated.
Parameters
Returns
Returns log likelihood sum and subsequent to an asynchronous integration call. This function is optional and only has to be called by clients that use the non-blocking asynchronous computation mode (BEAGLE_FLAG_COMPUTATION_ASYNCH).
If used, this function must be called after a beagleCalculateRootLogLikelihoods or beagleCalculateEdgeLogLikelihoods call. The library will block until the likelihood has been calculated.
Parameters
Returns
Get partials from an instance buffer. This function copies an instance buffer into the array outPartials. The outPartials array should be stateCount * patternCount * categoryCount in length.
Parameters
Returns
Get list of hardware resources. This function returns a pointer to a BeagleResourceList struct, which includes a BeagleResource array describing the available hardware resources.
Returns
Get scale factors. This function retrieves a buffer of scale factors.
Parameters
Get site derivatives for last beagleCalculateEdgeLogLikelihoods call. This function returns the derivatives for each site
Parameters
Returns
Get site log likelihoods for last beagleCalculateRootLogLikelihoods or beagleCalculateEdgeLogLikelihoods call. This function returns the log likelihoods for each site
Parameters
Returns
Get a finite-time transition probability matrix. This function copies a finite-time transition matrix buffer into the array outMatrix. The outMatrix array should be of size stateCount * stateCount * categoryCount and will be filled with one matrix for each rate category.
Parameters
Returns
Get version. This function returns a pointer to a string with the library version number.
Returns
Remove scale factors. This function removes (log) scale factors from a cumulative scale buffer. The scale factors to be removed are indicated in a list of scaleBuffers.
Parameters
Remove scale factors by partition. This function removes (log) scale factors from a cumulative scale buffer. The scale factors to be removed are indicated in a list of scaleBuffers.
Parameters
Reset scalefactors. This function resets a cumulative scale buffer.
Parameters
Reset scalefactors by partition. This function resets a cumulative scale buffer.
Parameters
Set the default category rates buffer. This function sets the default vector of category rates for an instance.
Parameters
Returns
Set a category rates buffer. This function sets the vector of category rates for a given buffer in an instance.
Parameters
Returns
Set a category weights buffer. This function copies a category weights array into an instance buffer.
Parameters
Returns
Set number of threads for native CPU implementation. This function sets the max number of worker threads to be used with a native CPU implementation. It should only be called after beagleCreateInstance and requires the BEAGLE_FLAG_THREADING_CPP flag to be set. It has no effect on GPU-based implementations. It has no effect with the default BEAGLE_FLAG_THREADING_NONE setting. If BEAGLE_FLAG_THREADING_CPP is set and this function is not called BEAGLE will use a heuristic to set an appropriate number of threads.
Parameters
Returns
Set an eigen-decomposition buffer. This function copies an eigen-decomposition into an instance buffer.
Parameters
Returns
Set an instance partials buffer. This function copies an array of partials into an instance buffer. The inPartials array should be stateCount * patternCount * categoryCount in length.
Parameters
Returns
Set pattern partition assignments. This function sets the vector of pattern partition indices for an instance. It should only be called after beagleSetTipPartials and beagleSetPatternWeights.
Parameters
Returns
Set pattern weights. This function sets the vector of pattern weights for an instance.
Parameters
Returns
Set a state frequency buffer. This function copies a state frequency array into an instance buffer.
Parameters
Returns
Set an instance partials buffer for tip node. This function copies an array of partials into an instance buffer. The inPartials array should be stateCount * patternCount in length. For most applications this will be used to set the partial likelihoods for the observed states. Internally, the partials will be copied categoryCount times.
Parameters
Returns
Set the compact state representation for tip node. This function copies a compact state representation into an instance buffer. Compact state representation is an array of states: 0 to stateCount - 1 (missing = stateCount). The inStates array should be patternCount in length (replication across categoryCount is not required).
Parameters
Returns
Set multiple transition matrices. This function copies multiple transition matrices into matrix buffers. This function is used when the application wishes to explicitly set the transition matrices rather than using the beagleSetEigenDecomposition and beagleUpdateTransitionMatrices functions. The inMatrices array should be of size stateCount * stateCount * categoryCount * count.
Parameters
Returns
Set a finite-time transition probability matrix. This function copies a finite-time transition probability matrix into a matrix buffer. This function is used when the application wishes to explicitly set the transition probability matrix rather than using the beagleSetEigenDecomposition and beagleUpdateTransitionMatrices functions. The inMatrix array should be of size stateCount * stateCount * categoryCount and will contain one matrix for each rate category.
Parameters
Returns
Calculate or queue for calculation partials using a list of operations. This function either calculates or queues for calculation a list partials. Implementations supporting ASYNCH may queue these calculations while other implementations perform these operations immediately and in order.
Parameters
Returns
Calculate or queue for calculation partials using a list of partition operations. This function either calculates or queues for calculation a list partitioned partials. Implementations supporting ASYNCH may queue these calculations while other implementations perform these operations immediately and in order.
Parameters
Returns
Calculate a list of transition probability matrices. This function calculates a list of transition probabilities matrices and their first and second derivatives (if requested).
Parameters
Returns
Calculate a list of transition probability matrices with multiple models. This function calculates a list of transition probabilities matrices and their first and second derivatives (if requested).
Parameters
Returns
Block until all calculations that write to the specified partials have completed. This function is optional and only has to be called by clients that 'recycle' partials.
If used, this function must be called after a beagleUpdatePartials call and must refer to indices of 'destinationPartials' that were used in a previous beagleUpdatePartials call. The library will block until those partials have been calculated.
Parameters
Returns
Generated automatically by Doxygen for BEAGLE from the source code.
| Mon Apr 22 2024 09:45:12 | Version 3.1.2 |