LocalScalarKernel

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

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

abstract val hyper_parameters: List[String]

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(c: Double): LocalScalarKernel[Index]

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

def *[T <: LocalScalarKernel[Index]](otherKernel: T)(implicit ev: ClassTag[Index]): CompositeCovariance[Index]

Create composite kernel k = k₁ * k₂

def +[T <: LocalScalarKernel[Index]](otherKernel: T)(implicit ev: ClassTag[Index]): CompositeCovariance[Index]

Create composite kernel k = k₁ + k₂

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

Construct the kronecker product kernel

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

final def ==(arg0: Any): Boolean

def >[K <: GenericRBFKernel[Index]](otherKernel: K): CompositeCovariance[Index]

Construct a 2 layer kernel K = k1 > rbf

final def asInstanceOf[T0]: T0

def asPipe: DataPipe[Map[String, Double], LocalScalarKernel[Index]]

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[Index]](dataset1: S, dataset2: S): PartitionedMatrix

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

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

def buildKernelMatrix[S <: Seq[Index]](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: Index, y: Index): Double

def finalize(): Unit

final def getClass(): Class[_]

def gradient(x: Index, y: Index): 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]): LocalScalarKernel.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