BatchDiffFunction

abstract def calculate(x: T, batch: IndexedSeq[Int]): (Double, T)

Calculates the value and gradient of the function on a subset of the data

abstract def fullRange: IndexedSeq[Int]

The full size of the data

final def !=(arg0: Any): Boolean

final def ##(): Int

final def %[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpMod.Impl2[TT, B, That]): That

Alias for :%(b) when b is a scalar.

final def %:%[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpMod.Impl2[TT, B, That]): That

Element-wise modulo of this and b.

final def %=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpMod.InPlaceImpl2[TT, B]): DiffFunction[T]

Alias for :%=(b) when b is a scalar.

final def &[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpAnd.Impl2[TT, B, That]): That

Alias for :&&(b) for all b.

final def &:&[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpAnd.Impl2[TT, B, That]): That

Element-wise logical "and" operator -- returns true if corresponding elements are non-zero.

final def &=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpAnd.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise and of this and b.

final def *[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpMulMatrix.Impl2[TT, B, That]): That

Matrix multiplication (and scalar multiplication that follows standard order of operations)

final def *:*[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpMulScalar.Impl2[TT, B, That]): That

Element-wise product of this and b.

final def *=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpMulScalar.InPlaceImpl2[TT, B]): DiffFunction[T]

Alias for :*=(b) when b is a scalar.

final def +[TT >: DiffFunction[T], B, C, That](b: B)(implicit op: linalg.operators.OpAdd.Impl2[TT, B, That]): That

Alias for :+(b) for all b.

final def +:+[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpAdd.Impl2[TT, B, That]): That

Element-wise sum of this and b.

final def +=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpAdd.InPlaceImpl2[TT, B]): DiffFunction[T]

Alias for :+=(b) for all b.

final def -[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpSub.Impl2[TT, B, That]): That

Alias for :-(b) for all b.

final def -:-[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpSub.Impl2[TT, B, That]): That

Element-wise difference of this and b.

final def -=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpSub.InPlaceImpl2[TT, B]): DiffFunction[T]

Alias for :-=(b) for all b.

final def /[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpDiv.Impl2[TT, B, That]): That

Alias for :/(b) when b is a scalar.

final def /:/[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpDiv.Impl2[TT, B, That]): That

Element-wise quotient of this and b.

final def /=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpDiv.InPlaceImpl2[TT, B]): DiffFunction[T]

Alias for :/=(b) when b is a scalar.

final def :!=[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpNe.Impl2[TT, B, That]): That

Element-wise inequality comparator of this and b.

final def :%=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpMod.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise modulo of b into this.

final def :&=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpAnd.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise and of this and b.

final def :*=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpMulScalar.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise multiplication of b into this.

final def :+=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpAdd.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise addition of b into this.

final def :-=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpSub.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise subtraction of b from this

final def :/=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpDiv.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise division of b into this

final def :=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpSet.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise assignment of b into this.

final def :==[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpEq.Impl2[TT, B, That]): That

Element-wise equality comparator of this and b.

final def :^=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpPow.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise exponentiation of this by b.

final def :^^=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpXor.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise xor of this and b.

final def :|=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpOr.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise or of this and b.

final def <:<[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpLT.Impl2[TT, B, That]): That

Element-wise less=than comparator of this and b.

final def <:=[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpLTE.Impl2[TT, B, That]): That

Element-wise less-than-or-equal-to comparator of this and b.

final def ==(arg0: Any): Boolean

final def >:=[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpGTE.Impl2[TT, B, That]): That

Element-wise greater-than-or-equal-to comparator of this and b.

final def >:>[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpGT.Impl2[TT, B, That]): That

Element-wise greater-than comparator of this and b.

def \[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpSolveMatrixBy.Impl2[TT, B, That]): That

Shaped solve of this by b.

final def ^:^[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpPow.Impl2[TT, B, That]): That

Element-wise exponentiation of this and b.

final def ^^[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpXor.Impl2[TT, B, That]): That

Alias for :^^(b) for all b.

final def ^^:^^[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpXor.Impl2[TT, B, That]): That

Element-wise logical "xor" operator -- returns true if only one of the corresponding elements is non-zero.

final def ^^=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpXor.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise xor of this and b.

def andThen[A](g: (Double) ⇒ A): (T) ⇒ A

def apply(x: T, batch: IndexedSeq[Int]): Double

final def apply(x: T): Double

final def asInstanceOf[T0]: T0

def cached(implicit copy: CanCopy[T]): DiffFunction[T]

def calculate(x: T): (Double, T)

Calculates both the value and the gradient at a point

def clone(): AnyRef

def compose[A](g: (A) ⇒ T): (A) ⇒ Double

def curried: (T) ⇒ (IndexedSeq[Int]) ⇒ Double

final def dot[TT >: DiffFunction[T], B, BB >: B, That](b: B)(implicit op: linalg.operators.OpMulInner.Impl2[TT, BB, That]): That

Inner product of this and b.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def gradientAt(x: T): T

calculates the gradient at a point

def gradientAt(x: T, batch: IndexedSeq[Int]): T

Calculates the gradient of the function on a subset of the data

def groupItems(groupSize: Int): BatchDiffFunction[T]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def repr: DiffFunction[T]

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

final def t[TT >: DiffFunction[T], That, Slice1, Result](a: Slice1)(implicit op: CanTranspose[TT, That], canSlice: CanSlice[That, Slice1, Result]): Result

A transposed view of this object, followed by a slice.

final def t[TT >: DiffFunction[T], That, Slice1, Slice2, Result](a: Slice1, b: Slice2)(implicit op: CanTranspose[TT, That], canSlice: CanSlice2[That, Slice1, Slice2, Result]): Result

A transposed view of this object, followed by a slice.

final def t[TT >: DiffFunction[T], That](implicit op: CanTranspose[TT, That]): That

A transposed view of this object.

def throughLens[U](implicit l: Isomorphism[T, U]): BatchDiffFunction[U]

Lenses provide a way of mapping between two types, which we typically use to convert something to a DenseVector or other Tensor for optimization purposes.

def toString(): String

def tupled: ((T, IndexedSeq[Int])) ⇒ Double

final def unary_![TT >: DiffFunction[T], That](implicit op: linalg.operators.OpNot.Impl[TT, That]): That

final def unary_-[TT >: DiffFunction[T], That](implicit op: linalg.operators.OpNeg.Impl[TT, That]): That

def valueAt(x: T): Double

calculates the value at a point

def valueAt(x: T, batch: IndexedSeq[Int]): Double

Calculates the value of the function on a subset of the data

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withRandomBatches(size: Int): StochasticDiffFunction[T]

def withScanningBatches(size: Int): StochasticDiffFunction[T]

final def |[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpOr.Impl2[TT, B, That]): That

Alias for :||(b) for all b.

final def |:|[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpOr.Impl2[TT, B, That]): That

Element-wise logical "or" operator -- returns true if either element is non-zero.

final def |=[TT >: DiffFunction[T], B](b: B)(implicit op: linalg.operators.OpOr.InPlaceImpl2[TT, B]): DiffFunction[T]

Mutates this by element-wise or of this and b.

final def :%[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpMod.Impl2[TT, B, That]): That

final def :&[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpAnd.Impl2[TT, B, That]): That

final def :*[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpMulScalar.Impl2[TT, B, That]): That

final def :+[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpAdd.Impl2[TT, B, That]): That

final def :-[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpSub.Impl2[TT, B, That]): That

final def :/[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpDiv.Impl2[TT, B, That]): That

final def :<[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpLT.Impl2[TT, B, That]): That

final def :<=[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpLTE.Impl2[TT, B, That]): That

final def :>[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpGT.Impl2[TT, B, That]): That

final def :>=[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpGTE.Impl2[TT, B, That]): That

final def :^[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpPow.Impl2[TT, B, That]): That

final def :^^[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpXor.Impl2[TT, B, That]): That

final def :|[TT >: DiffFunction[T], B, That](b: B)(implicit op: linalg.operators.OpOr.Impl2[TT, B, That]): That