cheshire-likelihood/cheshire.likelihood/PartitionKernel

PartitionKernel

trait PartitionKernel[F[_], R]
Companion:
object
class Object
trait Matchable
class Any

Type members

Classlikes

trait EdgeLikelihood
trait NodeLikelihood

Types

type Clv = NodeClv | TipClv
type Matrix
type Model
type NodeClv
type Partial = Ppv | Clv
type Ppv
type TipClv

Value members

Abstract methods

def allocateClv: Resource[F, NodeClv]
def allocateMatrix: Resource[F, Matrix]
def allocateModel: Resource[F, Model]
def allocatePpv: Resource[F, Ppv]
def backcast(y: Clv, P: Matrix, x: NodeClv): F[Unit]
def backcastProduct(y: Clv, Py: Matrix, z: Clv, Pz: Matrix, x: NodeClv): F[Unit]
def categoryCount: Int
def computeMatrix(model: Model, t: R, P: Matrix): F[Unit]
def edgeLikelihood: Resource[F, EdgeLikelihood]
def forecast(x: Ppv, P: Matrix, y: Ppv): F[Unit]
def initModel(freqs: IndexedSeq[R], params: IndexedSeq[R], rate: R, alpha: R, model: Model): F[Unit]
def integrateProduct(x: Ppv, y: Clv): F[R]
def nodeLikelihood: Resource[F, NodeLikelihood]
@targetName("ppvProduct")
def product(x: Ppv, y: Clv, z: Ppv): F[Unit]
@targetName("clvProduct")
def product(x: Clv, y: Clv, z: NodeClv): F[Unit]
def rates(model: Model): F[IndexedSeq[R]]
def seed(model: Model, x: Ppv): F[Unit]
def seedAndIntegrate(model: Model, x: Clv): F[R]
def tips: IndexedSeq[TipClv]

Concrete methods

final def imap[S](f: R => S)(g: S => R)(using Functor[F]): Aux[F, S, Model, Matrix, Ppv, NodeClv, TipClv]