SpectralProjectedGradient

Instance Constructors

new SpectralProjectedGradient(projection: (T) ⇒ T = (t: T) => t, tolerance: Double = 1e-6, suffDec: Double = 1e-4, fvalMemory: Int = 30, alphaMax: Double = 1e10, alphaMin: Double = 1e-10, bbMemory: Int = 10, maxIter: Int = 1, initFeas: Boolean = false, curvilinear: Boolean = false, bbType: Int = 1, maxSrcht: Int = 30)(implicit space: MutableVectorField[T, Double])

projection
projection operations
tolerance
termination criterion: tolerance for norm of projected gradient
suffDec
sufficient decrease parameter
alphaMax
longest step
alphaMin
shortest step
bbMemory
number of history entries for linesearch
maxIter
maximum number of iterations
initFeas
is the initial guess feasible, or should it be projected?
curvilinear
if curvilinear true, do the projection inside line search in place of doing it in chooseDescentDirection
maxSrcht
maximum number of iterations inside line search

Type Members

case class History(alphaBB: Double, fvals: IndexedSeq[Double]) extends Product with Serializable
type State = FirstOrderMinimizer.State[T, Info, History]

Definition Classes
FirstOrderMinimizer

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def adjust(newX: T, newGrad: T, newVal: Double): (Double, T)

Attributes
protected
Definition Classes
FirstOrderMinimizer
def adjustFunction(f: DiffFunction[T]): DiffFunction[T]

Attributes
protected
Definition Classes
FirstOrderMinimizer
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bbAlpha(s: T, y: T): Double

From Mark Schmidt's Matlab code if bbType == 1 alpha = (s'*s)/(s'*y); else alpha = (s'*y)/(y'*y);
From Mark Schmidt's Matlab code if bbType == 1 alpha = (s'*s)/(s'*y); else alpha = (s'*y)/(y'*y);

Attributes
protected
val bbType: Int
def calculateObjective(f: DiffFunction[T], x: T, history: History): (Double, T)

Attributes
protected
Definition Classes
FirstOrderMinimizer
def chooseDescentDirection(state: State, f: DiffFunction[T]): T

Attributes
protected
Definition Classes
SpectralProjectedGradient → FirstOrderMinimizer
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val convergenceCheck: ConvergenceCheck[T]

Definition Classes
FirstOrderMinimizer
val curvilinear: Boolean

if curvilinear true, do the projection inside line search in place of doing it in chooseDescentDirection
def determineStepSize(state: State, f: DiffFunction[T], direction: T): Double

Attributes
protected
Definition Classes
SpectralProjectedGradient → FirstOrderMinimizer
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def infiniteIterations(f: DiffFunction[T], state: State): Iterator[State]

Definition Classes
FirstOrderMinimizer
val initFeas: Boolean

is the initial guess feasible, or should it be projected?
def initialHistory(f: DiffFunction[T], init: T): History

Attributes
protected
Definition Classes
SpectralProjectedGradient → FirstOrderMinimizer
def initialState(f: DiffFunction[T], init: T): State

Attributes
protected
Definition Classes
FirstOrderMinimizer
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterations(f: DiffFunction[T], init: T): Iterator[State]

Definition Classes
FirstOrderMinimizer
def logger: LazyLogger

Attributes
protected
Definition Classes
SerializableLogging
val maxSrcht: Int

maximum number of iterations inside line search
def minimize(f: DiffFunction[T], init: T): T

Definition Classes
FirstOrderMinimizer → Minimizer
def minimizeAndReturnState(f: DiffFunction[T], init: T): State

Definition Classes
FirstOrderMinimizer
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def projectedVector(x: T, g: T)(implicit vspace: Module[T, Double]): T

Definition Classes
Projecting
val projection: (T) ⇒ T

projection operations
projection operations

Definition Classes
SpectralProjectedGradient → Projecting
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def takeStep(state: State, dir: T, stepSize: Double): T

Attributes
protected
Definition Classes
SpectralProjectedGradient → FirstOrderMinimizer
def toString(): String

Definition Classes
AnyRef → Any
def updateHistory(newX: T, newGrad: T, newVal: Double, f: DiffFunction[T], oldState: State): History

Attributes
protected
Definition Classes
SpectralProjectedGradient → FirstOrderMinimizer
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package optimize

class SpectralProjectedGradient[T] extends FirstOrderMinimizer[T, DiffFunction[T]] with Projecting[T] with SerializableLogging

Instance Constructors

Type Members

case class History(alphaBB: Double, fvals: IndexedSeq[Double]) extends Product with Serializable

type State = FirstOrderMinimizer.State[T, Info, History]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def adjust(newX: T, newGrad: T, newVal: Double): (Double, T)

def adjustFunction(f: DiffFunction[T]): DiffFunction[T]

final def asInstanceOf[T0]: T0

def bbAlpha(s: T, y: T): Double

val bbType: Int

def calculateObjective(f: DiffFunction[T], x: T, history: History): (Double, T)

def chooseDescentDirection(state: State, f: DiffFunction[T]): T

def clone(): AnyRef

val convergenceCheck: ConvergenceCheck[T]

val curvilinear: Boolean

def determineStepSize(state: State, f: DiffFunction[T], direction: T): Double

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def infiniteIterations(f: DiffFunction[T], state: State): Iterator[State]

val initFeas: Boolean

def initialHistory(f: DiffFunction[T], init: T): History

def initialState(f: DiffFunction[T], init: T): State

final def isInstanceOf[T0]: Boolean

def iterations(f: DiffFunction[T], init: T): Iterator[State]

def logger: LazyLogger

val maxSrcht: Int

def minimize(f: DiffFunction[T], init: T): T

def minimizeAndReturnState(f: DiffFunction[T], init: T): State

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def projectedVector(x: T, g: T)(implicit vspace: Module[T, Double]): T

val projection: (T) ⇒ T

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

def takeStep(state: State, dir: T, stepSize: Double): T

def toString(): String

def updateHistory(newX: T, newGrad: T, newVal: Double, f: DiffFunction[T], oldState: State): History

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from Projecting[T]

Inherited from FirstOrderMinimizer[T, DiffFunction[T]]

Inherited from SerializableLogging

Inherited from Serializable

Inherited from Serializable

Inherited from Minimizer[T, DiffFunction[T]]

Inherited from AnyRef

Inherited from Any

Ungrouped