LinearPDEKernel

abstract def _operator_hyper_parameters: List[String]

abstract val baseID: String

abstract val baseKernel: LocalScalarKernel[(I, Double)]

abstract def evaluateAt(config: Map[String, Double])(x: (I, Double), y: (I, Double)): Double

abstract def gradientAt(config: Map[String, Double])(x: (I, Double), y: (I, Double)): Map[String, Double]

abstract val hyper_parameters: List[String]

abstract def invOperatorKernel: (exIndexSet, exIndexSet) ⇒ Double

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(c: Double): LocalScalarKernel[(I, Double)]

Returns the kernel multiplied by a positive constant: k_new = k*c

def *[T <: LocalScalarKernel[(I, Double)]](otherKernel: T)(implicit ev: ClassTag[(I, Double)]): CompositeCovariance[(I, Double)]

Create composite kernel k = k₁ * k₂

def +[T <: LocalScalarKernel[(I, Double)]](otherKernel: T)(implicit ev: ClassTag[(I, Double)]): CompositeCovariance[(I, Double)]

Create composite kernel k = k₁ + k₂

def :*[T1](otherKernel: LocalScalarKernel[T1]): KroneckerProductKernel[(I, Double), T1]

Construct the kronecker product kernel

def :+[T1](otherKernel: LocalScalarKernel[T1]): CompositeCovariance[((I, Double), T1)]

final def ==(arg0: Any): Boolean

def >[K <: GenericRBFKernel[(I, Double)]](otherKernel: K): CompositeCovariance[(I, Double)]

Construct a 2 layer kernel K = k1 > rbf

final def asInstanceOf[T0]: T0

def asPipe: DataPipe[Map[String, Double], LocalScalarKernel[(I, Double)]]

Get a pipeline which when given a particular configuration of hyper-parameters returns this kernel function set with that configuration.

def block(h: String*): Unit

def block_all_hyper_parameters: Unit

var blocked_hyper_parameters: List[String]

def buildBlockedCrossKernelMatrix[S <: Seq[(I, Double)]](dataset1: S, dataset2: S): PartitionedMatrix

def buildBlockedKernelMatrix[S <: Seq[(I, Double)]](mappedData: S, length: Long): PartitionedPSDMatrix

def buildCrossKernelMatrix[S <: Seq[(I, Double)]](dataset1: S, dataset2: S): DenseMatrix[Double]

def buildKernelMatrix[S <: Seq[(I, Double)]](mappedData: S, length: Int): KernelMatrix[DenseMatrix[Double]]

def clone(): AnyRef

var colBlocking: Int

def effective_hyper_parameters: List[String]

def effective_state: Map[String, Double]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evaluate(x: (I, Double), y: (I, Double)): Double

def finalize(): Unit

final def getClass(): Class[_]

def gradient(x: (I, Double), y: (I, Double)): Map[String, Double]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var rowBlocking: Int

def setBlockSizes(s: (Int, Int)): Unit

def setHyperParameters(h: Map[String, Double]): LinearPDEKernel.this.type

var state: Map[String, Double]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit