PancakeDLRGP

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def basisMatrix: DenseMatrix[Double]

low-rank basis matrix, (outputdim*numberOfPoints)x(rank)

def basisMatrixScaled: DenseMatrix[Double]

scaled basis matrix, scaled with standard deviations ("W" [PPCA lit.] or "Q" [GP lit.])

def clone(): AnyRef

def coefficients(s: DiscreteField[D, DiscreteDomain[D], Value]): DenseVector[Double]

Get the low-rank expansion coefficients of a sample, respects model noise

lazy val coefficientsDistribution: MultivariateNormalDistribution

Get the probability distribution of the coefficients in the latent space of the model (multivariate standard normal).

val cov: DiscreteMatrixValuedPDKernel[D]

covariance of this Gaussian Process: underlying GP + local uncorrelated noise

val domain: DiscreteDomain[D]

domain where this Gaussian Process is defined (same as underling process)

final def eq(arg0: AnyRef): Boolean

final def getClass(): Class[_]

val gpModel: DiscreteLowRankGaussianProcess[D, DDomain, Value]

underlying discrete low-rank Gaussian Process, subspace model

def instance(c: DenseVector[Double]): DiscreteField[D, DDomain, Value]

Draw an instance from the model, instance of underlying DiscreteLowRankGaussianProcess

def instanceAtPoint(c: DenseVector[Double], pid: PointId): Value

Get instance at a specific point

def interpolateNearestNeighbor: GaussianProcess[D, Value]

interpolate this process with nearest neighbours

final def isInstanceOf[T0]: Boolean

def logpdf(instance: DiscreteField[D, DiscreteDomain[D], Value]): Double

Returns the log of the probability density of the instance

def marginal(pointIds: Seq[PointId])(implicit domainCreator: Create[D]): PancakeDLRGP[D, UnstructuredPointsDomain[D], Value]

Calculate the marginal distribution on a set of points

def matrixMinv: DenseMatrix[Double]

inverted intermediate matrix M

val mean: DiscreteField[D, DDomain, Value]

mean field

def meanVector: DenseVector[Double]

mean vector of underlying DLRGP model

final def ne(arg0: AnyRef): Boolean

val noiseDistribution: MultivariateNormalDistribution

Noise distribution, expands the low rank subspace distribution to whole domain/space

val noiseVariance: Double

isotropic noise variance, "subspace + N(0, noiseVariance)"

final def notify(): Unit

final def notifyAll(): Unit

val outputDim: Int

output dimension of GP, same as underlying

def pdf(instance: DiscreteField[D, DiscreteDomain[D], Value]): Double

Returns the probability density of the given instance, takes spherical noise term into account

def posterior(trainingData: IndexedSeq[(PointId, Value, MultivariateNormalDistribution)]): PancakeDLRGP[D, DDomain, Value]

Calculate the posterior model given point observations with an individual uncertainty for each

def posterior(trainingData: IndexedSeq[(PointId, Value)], sigma2: Double): PancakeDLRGP[D, DDomain, Value]

Calculate the posterior model given point observations with a common independent isotropic Gaussian noise

def project(s: DiscreteField[D, DiscreteDomain[D], Value]): DiscreteField[D, DDomain, Value]

Project the sample into this model, best reconstruction

val rank: Int

See DiscreteLowRankGaussianProcess.rank

def sample()(implicit rnd: Random): DiscreteField[D, DDomain, Value]

Draw a sample from the model, includes noise(!) (use underlying gpModel without noise)

def stddev: DenseVector[Double]

standard deviation along each basis direction

final def synchronized[T0](arg0: ⇒ T0): T0

def toDiscreteGaussianProcess: DiscreteGaussianProcess[D, DDomain, Value]

this process as a DiscreteGaussianProcess, full rank

def truncate(rank: Int): PancakeDLRGP[D, DDomain, Value]

truncate the underlying low rank GP model (drops components, does not change noise)

def variance: DenseVector[Double]

variance along each basis direction

implicit val vectorizer: Vectorizer[Value]

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit