Compilation fixes to LBFGS eigenMin and eigenMax

math/src/main/scala/breeze/optimize/LBFGS.scala

@@ -20,8 +20,6 @@ import breeze.linalg._
 import breeze.linalg.operators.OpMulMatrix
 import breeze.math.MutableInnerProductModule
 import breeze.optimize.linear.PowerMethod
-import breeze.optimize.proximal.QuadraticMinimizer
-import breeze.stats.distributions.Rand
 import breeze.util.SerializableLogging
 
 /**
@@ -88,13 +86,12 @@ class LBFGS[T](maxIter: Int = -1, m: Int=10, tolerance: Double=1E-9)
    * specified through DiffFunction through power iteration on ApproximateInverseHessian,
    * get the largest eigenvalue e and return 1/e
    *
-   * @param n the size of the problem, can be infered from memStep/memGradDelta
+   * @param init initial guess for eigen vector
    * @param state the current state of the optimization
    * @return minimium eigen eigen value
    */
-  protected def minEigen(n: Int, state: State) : Double = {
-    val pm = new PowerMethod[DenseVector[Double], LBFGS.ApproximateInverseHessian[T]]
-    val init = DenseVector.rand[Double](n, Rand.gaussian(0, 1))
+  protected def minEigen(init: T, state: State) : Double = {
+    val pm = new PowerMethod[T, LBFGS.ApproximateInverseHessian[T]]()(space,LBFGS.multiplyInverseHessian)
     val eigenMax = pm.eigen(init, state.history)
     1.0/eigenMax
   }
@@ -104,17 +101,16 @@ class LBFGS[T](maxIter: Int = -1, m: Int=10, tolerance: Double=1E-9)
    * through DiffFunction by doing a inverse power iteration using the CompactHessian representation
    * generated from ApproximateInverseHessian, get the largest eigenvalue e
    *
-   * @param n the size of the problem, can be infered from memStep/memGradDelta
+   * @param init initial guess for the eigen vector
    * @param state the current state of the optimization
    * @return maximum eigen value
    */
-  protected def maxEigen(n: Int, state: State, init: DenseVector[Double]) : Double = {
+  protected def maxEigen(init:T, state: State) : Double = {
     val compactHessian = new CompactHessian(state.history.m)
     val memStep = state.history.memStep.asInstanceOf[Seq[DenseVector[Double]]]
     val memGradDelta = state.history.memGradDelta.asInstanceOf[Seq[DenseVector[Double]]]
     (0 to state.history.historyLength).map{i => compactHessian.updated(memStep(i), memGradDelta(i))}
-    val init = DenseVector.rand[Double](n, Rand.gaussian(0, 1))
-    val pm = new PowerMethod[DenseVector[Double], CompactHessian]
+    val pm = new PowerMethod[T, CompactHessian]()(space, ProjectedQuasiNewton.multiplyCompactHessian)
     pm.eigen(init, compactHessian)
   }
 }

math/src/main/scala/breeze/optimize/ProjectedQuasiNewton.scala

@@ -2,6 +2,7 @@ package breeze.optimize
 
 import breeze.linalg._
 import breeze.collection.mutable.RingBuffer
+import breeze.linalg.operators.OpMulMatrix
 import breeze.math.{MutableInnerProductModule}
 import breeze.util.SerializableLogging
 
@@ -184,5 +185,11 @@ object ProjectedQuasiNewton {
       (f, g)
     }
   }
+
+  implicit def multiplyCompactHessian[T](implicit vspace: MutableInnerProductModule[T, Double]): OpMulMatrix.Impl2[CompactHessian, T, T] = {
+    new OpMulMatrix.Impl2[CompactHessian, T, T] {
+      def apply(a: CompactHessian, b: T): T = a * b
+    }
+  }
 }
 

math/src/main/scala/breeze/optimize/linear/PowerMethod.scala

@@ -17,7 +17,7 @@
 package breeze.optimize.linear
 
 import breeze.linalg.operators.OpMulMatrix
-import breeze.math.MutableInnerProductVectorSpace
+import breeze.math.{MutableInnerProductModule}
 import breeze.numerics.abs
 import breeze.util.SerializableLogging
 import breeze.linalg.norm
@@ -27,7 +27,8 @@ import breeze.util.Implicits._
  * Created by debasish83 on 2/3/15.
  */
 class PowerMethod[T, M](maxIterations: Int = 10,tolerance: Double = 1E-5)
-                       (implicit space: MutableInnerProductVectorSpace[T, Double], mult: OpMulMatrix.Impl2[M, T, T]) extends SerializableLogging {
+                       (implicit space: MutableInnerProductModule[T, Double],
+                        mult: OpMulMatrix.Impl2[M, T, T]) extends SerializableLogging {
 
   import space._
 
@@ -57,7 +58,10 @@ class PowerMethod[T, M](maxIterations: Int = 10,tolerance: Double = 1E-5)
 
     val val_dif = abs(lambda - eigenValue)
     if (val_dif <= tolerance || iter > maxIterations) State(lambda, ay, iter + 1, true)
-    else State(lambda, ay/lambda, iter + 1, false)
+    else {
+      ay *= 1.0/lambda
+      State(lambda, ay, iter + 1, false)
+    }
   }.takeUpToWhere(_.converged)
 
   def iterateAndReturnState(y: T, A: M): State = {