dlarrc function

void dlarrc(
  1. String JOBT,
  2. int N,
  3. double VL,
  4. double VU,
  5. Array<double> D_,
  6. Array<double> E_,
  7. double PIVMIN,
  8. Box<int> EIGCNT,
  9. Box<int> LCNT,
  10. Box<int> RCNT,
  11. Box<int> INFO,
)

Implementation

void dlarrc(
  final String JOBT,
  final int N,
  final double VL,
  final double VU,
  final Array<double> D_,
  final Array<double> E_,
  final double PIVMIN,
  final Box<int> EIGCNT,
  final Box<int> LCNT,
  final Box<int> RCNT,
  final Box<int> INFO,
) {
  final D = D_.having();
  final E = E_.having();
  const ZERO = 0.0;
  int I;
  bool MATT;
  double LPIVOT, RPIVOT, SL, SU, TMP, TMP2;

  INFO.value = 0;
  LCNT.value = 0;
  RCNT.value = 0;
  EIGCNT.value = 0;

  // Quick return if possible

  if (N <= 0) {
    return;
  }

  MATT = lsame(JOBT, 'T');

  if (MATT) {
    // Sturm sequence count on T
    LPIVOT = D[1] - VL;
    RPIVOT = D[1] - VU;
    if (LPIVOT <= ZERO) {
      LCNT.value++;
    }
    if (RPIVOT <= ZERO) {
      RCNT.value++;
    }
    for (I = 1; I <= N - 1; I++) {
      TMP = pow(E[I], 2).toDouble();
      LPIVOT = (D[I + 1] - VL) - TMP / LPIVOT;
      RPIVOT = (D[I + 1] - VU) - TMP / RPIVOT;
      if (LPIVOT <= ZERO) {
        LCNT.value++;
      }
      if (RPIVOT <= ZERO) {
        RCNT.value++;
      }
    }
  } else {
    // Sturm sequence count on L D L^T
    SL = -VL;
    SU = -VU;
    for (I = 1; I <= N - 1; I++) {
      LPIVOT = D[I] + SL;
      RPIVOT = D[I] + SU;
      if (LPIVOT <= ZERO) {
        LCNT.value++;
      }
      if (RPIVOT <= ZERO) {
        RCNT.value++;
      }
      TMP = E[I] * D[I] * E[I];

      TMP2 = TMP / LPIVOT;
      if (TMP2 == ZERO) {
        SL = TMP - VL;
      } else {
        SL = SL * TMP2 - VL;
      }

      TMP2 = TMP / RPIVOT;
      if (TMP2 == ZERO) {
        SU = TMP - VU;
      } else {
        SU = SU * TMP2 - VU;
      }
    }
    LPIVOT = D[N] + SL;
    RPIVOT = D[N] + SU;
    if (LPIVOT <= ZERO) {
      LCNT.value++;
    }
    if (RPIVOT <= ZERO) {
      RCNT.value++;
    }
  }
  EIGCNT.value = RCNT.value - LCNT.value;
}