public CM getMiddle() {
    return this.middle;
  }

  /**
   * {@inheritDoc}
   */
  public RM getRadius() {
    return this.radius;
  }

  /**
   * {@inheritDoc}
   */
  public boolean isPointMatrix() {
    return this.radius.isZero();
  }

  /**
   * {@inheritDoc}
   */
  public void printInfSup(String name, Writer output) {
    //TODO
    this.infimum.setElementFormat("%26.30E"); //$NON-NLS-1$
    this.supremum.setElementFormat("%26.30E"); //$NON-NLS-1$

    this.infimum.print(name + Messages.getString("RealIntervalMatrix.2"), output); //$NON-NLS-1$
    this.supremum.print(name + Messages.getString("RealIntervalMatrix.3"), output); //$NON-NLS-1$
  }

  /**
   * {@inheritDoc}
   */
  public void printMidRad(String name, Writer output) {
    //TODO
    this.middle.setElementFormat("%26.30E"); //$NON-NLS-1$
    this.radius.setElementFormat("%26.30E"); //$NON-NLS-1$

    this.middle.print(name + Messages.getString("RealIntervalMatrix.4"), output); //$NON-NLS-1$
    this.radius.print(name + Messages.getString("RealIntervalMatrix.5"), output); //$NON-NLS-1$
  }

  /**
   * 行列を1行の文字列に変換します。
   * 
   * @param elementFormat 成分の出力フォーマット
   * @return 1行の文字列
   */
  public String toString(final String elementFormat) {
    final int rowSize = getRowSize();
    final int columnSize = getColumnSize();

    final StringBuffer sb = new StringBuffer();

    if (rowSize == 0 || columnSize == 0) {
      return "[[]]"; //$NON-NLS-1$
    }

    if (columnSize == 1 && rowSize != 1) {
      return transpose().toString(elementFormat) + "'"; //$NON-NLS-1$
    }

    if (rowSize != 1) {
      sb.append("["); //$NON-NLS-1$
    }

    final int displayColumnSize = 1;

    for (int i = 0; i < rowSize; i++) {
      if (i != 0) {
        sb.append(" "); //$NON-NLS-1$
      }

      for (int k = 0; k < columnSize;) {
        if (k == 0) {
          sb.append("["); //$NON-NLS-1$
        } else {
          sb.append(" "); //$NON-NLS-1$ 
          if (rowSize != 1) {
            sb.append(" "); //$NON-NLS-1$ 
          }
        }

        int j;
        for (j = k; j < k + displayColumnSize && j < columnSize; j++) {
          sb.append((getElement(i + 1, j + 1)).toString(elementFormat));
          if (j != columnSize - 1) {
            sb.append(","); //$NON-NLS-1$
          }
        }

        if (j == columnSize) {
          sb.append("]"); //$NON-NLS-1$
        }

        k += displayColumnSize;
      }
    }

    if (rowSize != 1) {
      sb.append("]"); //$NON-NLS-1$
    }

    return sb.toString();
  }

  /**
   * {@inheritDoc}
   */
  public boolean contains(final CM point) {

    return createInfSup(inf, sup);
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix compareElementWise(String operator, int value) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value).andElementWise(this.supremum.compareElementWise(operator, value));
    }

    if (operator.equals(".!=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value).andElementWise(this.supremum.compareElementWise(operator, value));
    }

    if (operator.equals(".<")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, value);
    }

    if (operator.equals(".<=")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, value);
    }

    if (operator.equals(".>")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value);
    }

    if (operator.equals(".>=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value);
    }

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix compareElementWise(String operator, double value) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value).andElementWise(this.supremum.compareElementWise(operator, value));
    }

    if (operator.equals(".!=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value).andElementWise(this.supremum.compareElementWise(operator, value));
    }

    if (operator.equals(".<")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, value);
    }

    if (operator.equals(".<=")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, value);
    }

    if (operator.equals(".>")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value);
    }

    if (operator.equals(".>=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value);
    }

    throw new UnsupportedOperationException();
  }

  /**
   * @param operator operator
   * @param value value
   * @return result
   */
  public BooleanMatrix compareElementWise(String operator, RS value) {

      XX.setRowVectors(v, XX.createZero(v.getColumnSize(), XX.getColumnSize()));
      IY = IZ.add(IC.multiply(X)).add(IR.multiply(XX.multiply(X.getRowVectors(v))));
      ready = IntervalUtil.in0forRump(IY, X).allTrue();
    }

    CIM L = null;

    if (ready) {
      RM M = (IY.getRowVectors(v)).abssElementWise().getRealPart();

      if (v.length() == 1) {
        CS[] value = locallambda.createArray(1);
        value[0] = locallambda;
        CM mid = locallambda.createGrid(value);
        L = createMidRad(mid, M);
      } else {
        EigenSolution<RS,RM,CS,CM> EV = (M).eigenDecompose();
        ElementHolder<?> list = ((EV.getValue().diagonalToVector()).absElementWise()).maximum();
        int index = list.getRow();

        CM Perronx = EV.getVector().getColumnVector(index);

        manager.setRoundMode(RoundMode.ROUND_UP);

        /* upper bound for Perron root */
        RM rad = ((M.toComplex().multiply(Perronx).divideElementWise(Perronx))).maxColumnWise().getRealPart();

        manager.setRoundMode(RoundMode.ROUND_NEAR);
        CS[] value = locallambda.createArray(1);
        value[0] = locallambda;
        CM mid = locallambda.createGrid(value);
        L = createMidRad(mid, rad);
      }

      IY.setRowVectors(v, IY.createZero(v.getColumnSize(), IY.getColumnSize()));
      X = createInterval(xs).add(IY);
    } else {

      X = IY.add(Eps);
      XX.copy(X);
      XX.setRowVectors(v, XX.createZero(v.getColumnSize(), XX.getColumnSize()));
      CIM b = IZ.add(XX.multiply(X.getRowVectors(v)));
      IY = G.inverse().multiply(b);
      ready = IntervalUtil.in0forRump(IY, X).allTrue();
    }

    CIM L = null;

    if (ready) {
      RM M = (IY.getRowVectors(v)).abssElementWise().getRealPart();

      if (v.length() == 1) {
        CS[] value = locallambda.createArray(1);
        value[0] = locallambda;
        CM mid = locallambda.createGrid(value);
        L = createMidRad(mid, M);
      } else {
        EigenSolution<RS,RM,CS,CM> EV = (M).eigenDecompose();
        ElementHolder<?> list = (EV.getValue().diagonalToVector()).absElementWise().maximum();
        int index = list.getRow();

        CM Perronx = EV.getVector().getColumnVector(index);

        manager.setRoundMode(RoundMode.ROUND_UP);

        /* upper bound for Perron root */
        RM rad = ((M.toComplex().multiply(Perronx).divideElementWise(Perronx))).maxColumnWise().getRealPart();

        manager.setRoundMode(RoundMode.ROUND_NEAR);
        CS[] value = locallambda.createArray(1);
        value[0] = locallambda;
        CM mid = locallambda.createGrid(value);
        L = createMidRad(mid, rad);
      }

      IY.setRowVectors(v, IY.createZero(v.getColumnSize(), IY.getColumnSize()));

      return this.middle.compareElementWise(operator, value).andElementWise(this.radius.compareElementWise(operator, value.getRealPart().createZero()).notElementWise());
    }

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   */
  public void exchangeRow(int row1, int row2) {
    this.infimum.exchangeRow(row1, row2);
    this.supremum.exchangeRow(row1, row2);
    this.middle.exchangeRow(row1, row2);
    this.radius.exchangeRow(row1, row2);
  }

  /**
   * {@inheritDoc}
   */
  public void exchangeColumn(int column1, int column2) {
    this.infimum.exchangeColumn(column1, column2);
    this.supremum.exchangeColumn(column1, column2);
    this.middle.exchangeColumn(column1, column2);
    this.radius.exchangeColumn(column1, column2);
  }

  /**
   * {@inheritDoc}
   */
  public void removeRowVectors(int rowMinimum, int rowMaximum) {
    this.infimum.removeRowVectors(rowMinimum, rowMaximum);
    this.supremum.removeRowVectors(rowMinimum, rowMaximum);
    this.middle.removeRowVectors(rowMinimum, rowMaximum);
    this.radius.removeRowVectors(rowMinimum, rowMaximum);
  }

  /**
   * {@inheritDoc}
   */
  public void removeRowVectors(IntMatrix rowIndex) {
    this.infimum.removeRowVectors(rowIndex);
    this.supremum.removeRowVectors(rowIndex);
    this.middle.removeRowVectors(rowIndex);
    this.radius.removeRowVectors(rowIndex);
  }

  /**
   * {@inheritDoc}
   */
  public void removeColumnVectors(int columnMinimum, int columnMaximum) {
    this.infimum.removeColumnVectors(columnMinimum, columnMaximum);
    this.supremum.removeColumnVectors(columnMinimum, columnMaximum);
    this.middle.removeColumnVectors(columnMinimum, columnMaximum);
    this.radius.removeColumnVectors(columnMinimum, columnMaximum);
  }

  /**
   * {@inheritDoc}
   */
  public void removeColumnVectors(IntMatrix columnIndex) {
    this.infimum.removeColumnVectors(columnIndex);
    this.supremum.removeColumnVectors(columnIndex);
    this.middle.removeColumnVectors(columnIndex);
    this.radius.removeColumnVectors(columnIndex);
  }

  /**
   * {@inheritDoc}
   */
  public CM getInfimum() {

    RS b_mid_imag = value.getMiddle().getImaginaryPart();

    manager.setRoundMode(RoundMode.ROUND_DOWN);

    RS c1_real = a_mid_real.multiply(b_mid_real).add(a_mid_imag.unaryMinus().multiply(b_mid_imag));
    RS c1_imag = a_mid_real.multiply(b_mid_imag).add(a_mid_imag.multiply(b_mid_real));
    CS c1 = this.middle.create(c1_real, c1_imag);

    manager.setRoundMode(RoundMode.ROUND_UP);

    RS c2_real = a_mid_real.multiply(b_mid_real).add(a_mid_imag.unaryMinus().multiply(b_mid_imag));
    RS c2_imag = a_mid_real.multiply(b_mid_imag).add(a_mid_imag.multiply(b_mid_real));
    CS c2 = this.middle.create(c2_real, c2_imag);

    CS mid = c1.add(c2.subtract(c1).divide(2));
    RS rad;

    if (this.radius.isZero()) {
      if (value.getRadius().isZero()) {
        rad = mid.subtract(c1).abs().getRealPart();
      } else {
        rad = mid.subtract(c1).abs().getRealPart().add(this.middle.abs().getRealPart()).add(value.getRadius());
      }
    } else if (value.getRadius().isZero()) {
      rad = mid.subtract(c1).abs().getRealPart().add(this.radius.multiply(value.getMiddle().abs().getRealPart()));

    CIM BI = createInterval(nB);
    return BI;
  }

  /**
   * get a index array from P matrix.
   * 
   * @param n dimension of P matrix
   * @param p dimension of index array
   * @param P P matrix of LU decomposition
   * @return index array
   */
  private int[] getIndexArray(final int n, final int p, IntMatrix P) {
    int[] I = new int[p];
    for (int nRow = 0; nRow < p; nRow++) {
      int pRow = 0, pCol = n;
      for (int iRow = 1; iRow <= n; iRow++) {
        for (int iCol = 1; iCol <= n; iCol++) {
          if (P.getIntElement(iRow, iCol) == 1) {
            if (iCol < pCol) {
              pCol = iCol;
              pRow = iRow;
            }
          }
        }
      }

      P.setElement(pRow, pCol, 0);
      if (pRow - 1 == 0) {
        pRow = n + 1;
      }
      I[nRow] = pRow - 1;
    }
    return I;
  }

  /**
   * get a non-index array from index array based on P matrix.
   * 
   * @param n dimension of P matrix
   * @param p p
   * @param I index array
   * @return non-index array from index array
   */
  private int[] getNonIndexArray(final int n, final int p, int[] I) {
    int[] N = new int[n - p];
    int countIndex = 0;

    for (int nRow = 1; nRow <= n; nRow++) {
      if (this.isI(I, nRow) == false) {
        N[countIndex++] = nRow;
      }
    }

    return N;
  }

  /**
   * check data whether is the value of array or not.
   * 
   * @param i array data
   * @param target target value
   * @return if it is the value of array <code>i</code>, true; else, false.
   */
  private boolean isI(int[] i, int target) {
    for (int nRow = 0; nRow < i.length; nRow++) {
      if (i[nRow] == target) {
        return true;
      }
    }

    return false;
  }

  /**
   * @param sparseVectorFi information of sparse block-matrices <code>F</code>
   * @param c2 vector <code>c</code>
   * @param sparseVectorY information of sparse matrix <code>Y</code>
   * @return a verified sparse matrix <code>Y</code>
   */
  public CS[] getVULS(CS[][] sparseVectorFi, CS[] c2, CS[] sparseVectorY) {

public class ComplexNonlinearEquationVerifier<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>>{

  /** 関数オブジェクト */
  private IntervalDerivativeFunction<CIDS,CIDM,CIS,CIM,CS,CM> function;

public abstract class AbstractIntervalDerivativeComplexMatrix<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends AbstractIntervalDerivativeMatrix<CIDS, CIDM, CIS, CIM, CS, CM>

public abstract class AbstractIntervalDerivativeComplexNumber<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends AbstractIntervalDerivativeNumber<CIDS, CIDM, CIS, CIM, CS, CM>

public interface IntervalDerivativeComplexMatrix<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends IntervalDerivativeMatrix<CIDS, CIDM, CIS, CIM, CS, CM> {

public interface IntervalDerivativeComplexNumber<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends IntervalDerivativeNumber<CIDS, CIDM, CIS, CIM, CS, CM> {

public abstract class AbstractIntervalDerivativeComplexMatrix<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends AbstractIntervalDerivativeMatrix<CIDS, CIDM, CIS, CIM, CS, CM>

public abstract class AbstractIntervalDerivativeComplexMatrix<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends AbstractIntervalDerivativeMatrix<CIDS, CIDM, CIS, CIM, CS, CM>

    S[] d2 = unit.createArray(M.length());

    for (int i = 0; i < D.length(); i++) {
      d1[i] = D.getElement(i + 1, 1);
      d2[i] = M.getElement(i + 1, 1);
    }

    Ac = Ac.subtract(d1[0].createGrid(d1).vectorToDiagonal()).add(d2[0].createGrid(d2).vectorToDiagonal());
    return Ac;
  }

  /**
   * Comparison Matrixを求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param im 区間行列
   * @return ComparisonMatrix
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM comparisonMatrix(

    RM rad;

    if (isPointMatrix()) {
      if (y.isPointMatrix()) {
        rad = (mid.subtract(c1)).absElementWise().getRealPart();
      } else {
        rad = (mid.subtract(c1)).absElementWise().getRealPart().add((this.middle).absElementWise().getRealPart().multiply(y.getRadius()));
      }
    } else if (y.isPointMatrix()) {
      rad = (mid.subtract(c1)).absElementWise().getRealPart().add(this.radius.multiply((y.getMiddle()).absElementWise().getRealPart()));
    } else {
      rad = (mid.subtract(c1)).absElementWise().getRealPart().add(this.radius.multiply((y.getMiddle()).absElementWise().getRealPart().add(y.getRadius())))
          .add((this.middle).absElementWise().getRealPart().multiply(y.getRadius()));
    }

    IC = II.subtract(IR.multiply(IC));// C=I-RC
    CIM IY = IZ.createClone();// Y=Z

    CIM Eps = createInterval(IY.abssElementWise().multiply(0.1)).multiply(createIntervalInfSup(-1.0, 1.0)).addElementWise(createMidRad(0, Double.MIN_VALUE));
    // TODO こうしたらいいのかな？(NumericalMatrixElementIntervalの実装が必要みたい)
    CIM Z_row = IZ.getRowVectors(v);
    CM Z_row_abs = Z_row.abssElementWise();
    BooleanMatrix Z_flag = Z_row_abs.compareElementWise(".>", 0.1); //$NON-NLS-1$
    int z_sum = Z_flag.find().length();

    double m = 0;
    double mmax = Math.min(15 * (z_sum + 1), 20);

    boolean ready = false;

    CIM X = null;
    CIM XX = createInterval(R.createZero(IY.getRowSize(), IY.getColumnSize()));

    while ((!ready) && (m < mmax) && (!IY.isNanElementWise().anyTrue())) {
      m = m + 1;
      X = IY.add(Eps);
      XX.copy(X);
      XX.setRowVectors(v, XX.createZero(v.getColumnSize(), XX.getColumnSize()));

  public BooleanMatrix compareElementWise(String operator, RIM opponent) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, opponent.getInfimum()).andElementWise(this.supremum.compareElementWise(operator, opponent.getSupremum()));
    }

    if (operator.equals(".!=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, opponent.getInfimum()).andElementWise(this.supremum.compareElementWise(operator, opponent.getSupremum()));
    }

    if (operator.equals(".<")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, opponent.getInfimum());
    }

    if (operator.equals(".<=")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, opponent.getInfimum());
    }

    if (operator.equals(".>")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, opponent.getSupremum());
    }

    if (operator.equals(".>=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, opponent.getSupremum());
    }

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   */
  public RIM getSubVector(final IntMatrix index) {

public class ComplexBFMethod<RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> implements ComplexEigenVerifier<RIS,RIM,CIS,CIM,RS,RM,CS,CM> {

  /** 対象となる行列 */
  private CM A;
  /** 対象となる区間行列 */
  private CIM IA;
  /** 精度保証付き固有値 */
  private CIM verifiedValue;

  //  /** 精度保証付き固有ベクトル */
  //  private CIM verifiedVector;

//  /**
//   * コンストラクタ
//   * 
//   */
  
//  /**
//   * Creates {@link ComplexBFMethod}.
//   */
//  public ComplexBFMethod() {
//    // nothing to do
//  }

//  /**
//   * 新しく生成された<code>BFMethod</code>オブジェクトを初期化します。
//   * 
//   * @param A matrix
//   * 
//   * @param IA interval matrix
//   */
//  public ComplexBFMethod(CM A, CIM IA) {
//    this.A = A;
//    this.IA = IA;
//  }

//  /**
//   * 新しく生成された<code>BFMethod</code>オブジェクトを初期化します。
//   * 
//   * @param IA 対象となる区間行列
//   */
//  public ComplexBFMethod(CIM IA) {
//    this.IA = IA;
//    this.A = IA.getMiddle();
//  }

//  /**
//   * {@inheritDoc}
//   */
//  public void solve() {
//    EigenSolution<RS,RM,CS,CM> eigen = this.A.eigenDecompose();
//    CM value = eigen.getValues();
//    CM vector = eigen.getVectors();
//    this.verifiedValue = solve(value, vector);
//  }

//  /**
//   * @see org.mklab.cga.eigen.EigenVerifier#solveAsSparse()
//   */
//  public void solveAsSparse() {
//    if (this.A != null) {
//      solveAsSparse(this.A);
//    } else if (this.IA != null) {
//      solveAsSparse(this.IA);
//    } else {
//      throw new RuntimeException("Target matrix is not given."); //$NON-NLS-1$
//    }
//  }

//  /**
//   * {@inheritDoc}
//   */
//  public void solve(final CM a) {
//    this.A = a;
//    EigenSolution<RS,RM,CS,CM> eigen = (this.A).eigenDecompose();
//    CM value = eigen.getValues();
//    CM vector = eigen.getVectors();
//    this.verifiedValue = solve(value, vector);
//  }

  /**
   * {@inheritDoc}
   */
  public void solve(final CIM a) {
    this.IA = a;
    this.A = a.getMiddle();
    EigenSolution<RS,RM,CS,CM> eigen = this.A.eigenDecompose();

    List<CIM> value1;

    while (dxsnew.compareElementWise(".<", dxs.multiply(5)).anyTrue() //$NON-NLS-1$
        && (dxsnew).norm(NormType.TWO).isGreaterThan((xs).norm(NormType.TWO).multiply(sqrtN * 1e-14)) && k < 100 || k < 3) {
      k = k + 1;
      dxs = dxsnew.createClone();
      xsold = xss.createClone();

      for (int i = 0; i < xss.getRowSize(); i++) {
        idxss[i] = ids.create(is.create((xss).getElement(i + 1)), is.create(element.createUnit()));
      }
      value1 = nee.getValues(idxss);
      // f(x)
      y_x = value1.get(0).getMiddle();
      // ヤコビ行列
      y_dx = value1.get(2).getMiddle();
      xss = xss.subtract(y_dx.leftDivide(y_x));
      dxsnew = xss.subtract(xsold).absElementWise();
    }

    EigenSolution<RS,RM,CS,CM> eigen = this.A.eigenDecompose();
    CM value = eigen.getValue();
    CM vector = eigen.getVector();
    this.verifiedValue = solve(value, vector);
  }

//  /**
//   * {@inheritDoc}
//   */
//  public void solveAsSparse(CM a) {
//    throw new UnsupportedOperationException();
//  }

//  /**
//   * @see org.mklab.cga.eigen.EigenVerifier#getSolution()
//   */
//  public EigenVerifiedSolution<E> getSolution() {
//    return new EigenVerifiedSolution<>(this.verifiedValue);
//  }

  /**
   * @param value 近似固有値
   * @param vector 近似固有ベクトル
   * @return 精度保証付き固有値
   */
  private CIM solve(CM value, CM vector) {
    RoundModeManager manager = RoundModeManager.getManager();
    RoundMode oldRoundMode = manager.getRoundMode();

    manager.setRoundMode(RoundMode.ROUND_DOWN);
    CM v_down = vector.multiply(value);

    manager.setRoundMode(RoundMode.ROUND_UP);
    CM v_up = vector.multiply(value);
    CM v_m = v_down.add((v_up.subtract(v_down)).divide(2));
    CM v_r = v_m.subtract(v_down);

    manager.setRoundMode(RoundMode.ROUND_DOWN);

    CM e_down = v_m.multiply(vector.inverse()).add(v_r.multiply(-1).multiply((vector.inverse()).absElementWise())).subtract(this.A);

  public boolean compare(String operator, int opponent) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      if (this.infimum.equals(this.infimum.create(opponent)) && this.supremum.equals(this.supremum.create(opponent))) {
        return true;
      }
    } else if (operator.equals(".!=")) { //$NON-NLS-1$
      if (this.infimum.equals(this.infimum.create(opponent)) == false || this.supremum.equals(this.supremum.create(opponent)) == false) {
        return true;
      }
      return false;
    } else if (operator.equals(".<")) { //$NON-NLS-1$
      throw new UnsupportedOperationException();
    } else if (operator.equals(".<=")) { //$NON-NLS-1$
      throw new UnsupportedOperationException();
    } else if (operator.equals(".>")) { //$NON-NLS-1$
      throw new UnsupportedOperationException();
    } else if (operator.equals(".>=")) { //$NON-NLS-1$
      throw new UnsupportedOperationException();
    } else {
      throw new UnsupportedOperationException();
    }

    return true;
  }

  /**
   * {@inheritDoc}
   */
  public boolean compare(String operator, double opponent) {

    return createMidRad(mid, rad);
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix compareElementWise(String operator, int value) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      return this.middle.compareElementWise(operator, value).andElementWise(this.radius.compareElementWise(operator, value));
    }

    if (operator.equals(".!=")) { //$NON-NLS-1$
      return this.middle.compareElementWise(operator, value).andElementWise(this.radius.compareElementWise(operator, value));
    }

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix compareElementWise(String operator, double value) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      return this.middle.compareElementWise(operator, value).andElementWise(this.radius.compareElementWise(operator, value));
    }

    if (operator.equals(".!=")) { //$NON-NLS-1$
      return this.middle.compareElementWise(operator, value).andElementWise(this.radius.compareElementWise(operator, value));
    }

    throw new UnsupportedOperationException();
  }

  /**
   * @param operator operator
   * @param value value
   * @return result result
   */
  public BooleanMatrix compareElementWise(String operator, CS value) {

    CM vector = this.A.createZero(D1.getRowSize(), D1.getColumnSize());
    vector.setColumnVectors((D1.diagonalToVector()).sort().getIndices().transpose(), P1);

    this.verifiedValue = solve(value, vector);
  }

//  /**
//   * @see org.mklab.cga.eigen.EigenVerifier#getSolution()
//   */
//  public EigenVerifiedSolution<E> getSolution() {
//    return new EigenVerifiedSolution<>(this.verifiedValue);
//  }

//  /**
//   * {@inheritDoc}
//   */
//  public void solve(final CIM a) {
//    this.IA = a;
//    this.A = a.getMiddle();
//    solve();
//  }

//  /**
//   * {@inheritDoc}
//   */
//  public void solveAsSparse(CM a) {
//    throw new UnsupportedOperationException();
//  }

  /**
   * 精度保証付き固有値を返します。
   * 
   * @param value 近似固有値
   * @param vector 近似固有ベクトル
   * 
   * @return 精度保証付き固有値
   */
  private CIM solve(CM value, CM vector) {
    RoundModeManager manager = RoundModeManager.getManager();
    RoundMode oldRoundMode = manager.getRoundMode();

    manager.setRoundMode(RoundMode.ROUND_DOWN);

    CM v_down = vector.multiply(value);

    manager.setRoundMode(RoundMode.ROUND_UP);

    CM v_up = vector.multiply(value);
    CM mV = v_down.add((v_up.subtract(v_down)).divide(2));
    CM rV = mV.subtract(v_down);

    manager.setRoundMode(RoundMode.ROUND_DOWN);

    CM e_down = mV.multiply(vector.transpose()).add(rV.multiply(-1).multiply((vector.transpose()).absElementWise())).subtract(this.A);

  public BooleanMatrix compareElementWise(String operator, int value) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value).andElementWise(this.supremum.compareElementWise(operator, value));
    }

    if (operator.equals(".!=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value).andElementWise(this.supremum.compareElementWise(operator, value));
    }

    if (operator.equals(".<")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, value);
    }

    if (operator.equals(".<=")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, value);
    }

    if (operator.equals(".>")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value);
    }

    if (operator.equals(".>=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value);
    }

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix compareElementWise(String operator, double value) {

    return create(this.middle.createUnit(rowSize, columnSize));
  }

  /**
   * {@inheritDoc}
   */
  public boolean isZero(final double tolerance) {
    return this.middle.isZero(tolerance) && this.radius.isZero(tolerance);
  }

  /**
   * {@inheritDoc}
   */
  public boolean isUnit(final double tolerance) {
    return this.middle.isUnit(tolerance) && this.radius.isZero(tolerance);
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix isNanElementWise() {
    return (this.middle.isNanElementWise()).orElementWise(this.radius.isNanElementWise());
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix isInfiniteElementWise() {
    return (this.middle.isInfiniteElementWise()).orElementWise(this.radius.isInfiniteElementWise());
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix isFiniteElementWise() {
    return (this.middle.isFiniteElementWise()).andElementWise(this.radius.isFiniteElementWise());
  }

  /**
   * {@inheritDoc}
   */
  public boolean isReal() {
    return false;
  }

  /**
   * {@inheritDoc}
   */
  public boolean isComplex() {
    return true;
  }

  /**
   * {@inheritDoc}
   */
  public CIM add(final CIM y) {

  public BooleanMatrix compareElementWise(String operator, int value) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value).andElementWise(this.supremum.compareElementWise(operator, value));
    }

    if (operator.equals(".!=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value).andElementWise(this.supremum.compareElementWise(operator, value));
    }

    if (operator.equals(".<")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, value);
    }

    if (operator.equals(".<=")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, value);
    }

    if (operator.equals(".>")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value);
    }

    if (operator.equals(".>=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, value);
    }

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   */
  public BooleanMatrix compareElementWise(String operator, double value) {

  public BooleanMatrix compareElementWise(String operator, IntMatrix opponent) {
    if (operator.equals(".==")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, opponent).andElementWise(this.supremum.compareElementWise(operator, opponent));
    }

    if (operator.equals(".!=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, opponent).andElementWise(this.supremum.compareElementWise(operator, opponent));
    }

    if (operator.equals(".<")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, opponent);
    }

    if (operator.equals(".<=")) { //$NON-NLS-1$
      return this.supremum.compareElementWise(operator, opponent);
    }

    if (operator.equals(".>")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, opponent);
    }

    if (operator.equals(".>=")) { //$NON-NLS-1$
      return this.infimum.compareElementWise(operator, opponent);
    }

    throw new UnsupportedOperationException();
  }

  /**
   * 行列<code>opponent</code>の各成分と成分毎に<code>operator</code>で指定された演算子で比較し, それぞれの結果を成分とする{@link BooleanMatrix}を生成します。
   * 
   * @param operator 比較演算子(". &lt;", ". &lt;=", ".&gt;", ".&gt;=", ".==", ".!=")
   * @param opponent 比較対象
   * 
   * @return 比較結果を成分とする{@link BooleanMatrix}
   */
  public BooleanMatrix compareElementWise(String operator, DoubleMatrix opponent) {

    RS mid = inf.add(sup.subtract(inf).divide(2));

    manager.setRoundMode(oldRoundMode);
    return mid;
  }

  /**
   * 区間の半径を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param inf infimum
   * @param sup supremum
   * 
   * @return 区間の半径。
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS radius(

public class RealBFMethod<RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> implements RealEigenVerifier<RIS,RIM,CIS,CIM,RS,RM,CS,CM> {

  /** 対象となる行列 */
  private RM A;
  /** 対象となる区間行列 */
  private RIM IA;
  /** 精度保証付き固有値 */
  private CIM verifiedValue;

  //  /** 精度保証付き固有ベクトル */
  //  private CIM verifiedVector;

//  /**
//   * コンストラクタ
//   * 
//   */
//  public RealBFMethod() {
//    //
//  }

//  /**
//   * 新しく生成された<code>BFMethod</code>オブジェクトを初期化します。
//   * 
//   * @param A matrix
//   * @param IA interval matrix
//   */
//  public RealBFMethod(RM A, RIM IA) {
//    this.A = A;
//    this.IA = IA;
//  }

  /**
   * 新しく生成された<code>BFMethod</code>オブジェクトを初期化します。
   * 
   * @param IA 対象となる区間行列
   */
  public RealBFMethod(RIM IA) {

public class ComplexBFMethod<RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> implements ComplexEigenVerifier<RIS,RIM,CIS,CIM,RS,RM,CS,CM> {

  /** 対象となる行列 */
  private CM A;
  /** 対象となる区間行列 */
  private CIM IA;
  /** 精度保証付き固有値 */
  private CIM verifiedValue;

    CIM Eps = createInterval(IY.abssElementWise().multiply(0.1)).multiply(createIntervalInfSup(-1.0, 1.0)).addElementWise(createMidRad(0, Double.MIN_VALUE));
    // TODO こうしたらいいのかな？(NumericalMatrixElementIntervalの実装が必要みたい)
    CIM Z_row = IZ.getRowVectors(v);
    CM Z_row_abs = Z_row.abssElementWise();
    BooleanMatrix Z_flag = Z_row_abs.compareElementWise(".>", 0.1); //$NON-NLS-1$
    int z_sum = Z_flag.find().length();

    double m = 0;
    double mmax = Math.min(15 * (z_sum + 1), 20);

    boolean ready = false;

    CIM X = null;
    CIM XX = createInterval(R.createZero(IY.getRowSize(), IY.getColumnSize()));

    while ((!ready) && (m < mmax) && (!IY.isNanElementWise().anyTrue())) {
      m = m + 1;
      X = IY.add(Eps);

      final M A, final M x, final M b) {
    return residual(A, x, b);
  }

  /**
   * 残差を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param A 係数行列
   * @param x 解
   * @param b 右辺ベクトル
   * @return 残差
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM lssresidual(
      final RM A, final RM x, final RM b) {

    BooleanMatrix res = B.getInfimum().compareElementWise(".<", A.getInfimum()).andElementWise(A.getSupremum().compareElementWise(".<", B.getSupremum())); //$NON-NLS-1$ //$NON-NLS-2$
    manager.setRoundMode(oldRoundMode);
    return res;
  }

  /**
   * 区間行列Aが区間行列B内に含まれるかどうかを判定します。
   * 
   * @param A 区間
   * @param B 区間
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @return 区間に含まれる要素はtrue, 含まれない要素はfalse
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BooleanMatrix in0(

      res = d.add(A.getRadius()).compareElementWise(".<", B.getRadius()); //$NON-NLS-1$
    }

    manager.setRoundMode(oldRoundMode);
    return res;
  }

  /**
   * @param A A
   * @param B B
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @return boolean
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BooleanMatrix in0forRump(

    RM inf = mid.subtract(rad);

    manager.setRoundMode(oldRoundMode);
    return inf;
  }

  /**
   * 上限を返します。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param mid 中心
   * @param radus 半径
   * @return 上限
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM supremum(RM mid, RM radus) {

      final M A, final M x, final M b) {
    return residual(A, x, b);
  }

  /**
   * 残差を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param A 係数行列
   * @param x 解
   * @param b 右辺ベクトル
   * @return 残差
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM lssresidual(

    manager.setRoundMode(oldRoundMode);
    return res;
  }

  /**
   * 区間行列Aが区間行列B内に含まれるかどうかを判定します。
   * 
   * @param A 区間
   * @param B 区間
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @return 区間に含まれる要素はtrue, 含まれない要素はfalse
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BooleanMatrix in0(
      final CIM A, final CIM B) {

    manager.setRoundMode(oldRoundMode);
    return res;
  }

  /**
   * @param A A
   * @param B B
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @return boolean
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BooleanMatrix in0forRump(
      final RIM A, final RIM B) {

    RM b_imag = y.getImaginaryPart();

    manager.setRoundMode(RoundMode.ROUND_DOWN);
    RM c1_real = a_mid_real.multiply(b_real).add(a_mid_imag.unaryMinus().multiply(b_imag));
    RM c1_imag = a_mid_real.multiply(b_imag).add(a_mid_imag.multiply(b_real));
    CM c1 = this.radius.createComplex(c1_real, c1_imag);

    manager.setRoundMode(RoundMode.ROUND_UP);
    RM c2_real = a_mid_real.multiply(b_real).add(a_mid_imag.unaryMinus().multiply(b_imag));
    RM c2_imag = a_mid_real.multiply(b_imag).add(a_mid_imag.multiply(b_real));
    CM c2 = this.radius.createComplex(c2_real, c2_imag);

    CM mid = c1.add(c2.subtract(c1).divide(2));
    RM rad;

    }

    return ris.createGrid(riss);
  }

  /**
   * Creates interval matrix.
   * 
   * @param rs RS
   * @param ris RIS
   * @return RIM
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RIM create(

    }

    return cis.createGrid(ciss);
  }

  /**
   * Creates interval matrix.
   * 
   * @param cs CS
   * @param ris RIS
   * @return RIM
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CIM create(

    RS b_mid_imag = value.getMiddle().getImaginaryPart();

    manager.setRoundMode(RoundMode.ROUND_DOWN);

    RS c1_real = a_mid_real.multiply(b_mid_real).add(a_mid_imag.unaryMinus().multiply(b_mid_imag));
    RS c1_imag = a_mid_real.multiply(b_mid_imag).add(a_mid_imag.multiply(b_mid_real));
    CS c1 = this.middle.create(c1_real, c1_imag);

    manager.setRoundMode(RoundMode.ROUND_UP);

    RS c2_real = a_mid_real.multiply(b_mid_real).add(a_mid_imag.unaryMinus().multiply(b_mid_imag));
    RS c2_imag = a_mid_real.multiply(b_mid_imag).add(a_mid_imag.multiply(b_mid_real));
    CS c2 = this.middle.create(c2_real, c2_imag);

    CS mid = c1.add(c2.subtract(c1).divide(2));
    RS rad;

    CM mid = inf.add(sup.subtract(inf).divide(2));

    manager.setRoundMode(oldRoundMode);
    return mid;
  }
  
  /**
   * 区間の半径を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param inf infimum
   * @param sup supremum
   * @return 区間の半径。
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM radius(CM inf, CM sup) {

    RS sup = mid.add(rad);

    manager.setRoundMode(oldRoundMode);
    return sup;
  }

  /**
   * 上限を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * 
   * @param mid middle
   * @param rad radius
   * @return 上限
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CS supremum(

    RM rad = mid.subtract(inf).absElementWise().getRealPart();

    manager.setRoundMode(oldRoundMode);
    return rad;
  }
  
  /**
   * 下限を返します。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param mid 中心
   * @param rad 半径
   * @return 下限
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM infimum(RM mid, RM rad) {

    return xyZeroMean.conjugateTranspose().multiply(xyZeroMean).divide(size - 1);
  }
  
  /**
   * 区間の中心を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param inf infimum
   * @param sup supremum
   * @return 区間の中心。
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CM middle(

    return create(rm.getElements(), ris);
  }

  /**
   * Creates interval matrix.
   * 
   * @param cs CS
   * @param ris RIS
   * @return RIM
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CIM create(

public class ComplexVULS<RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>>  {
  /**
   * The number of matrix
   */
  private int m;
  /**
   * The constant <code>unit</code> based on a general data type
   */
  private CS unit;

public interface ComplexEigenVerifier<RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> {
  /**
   * 精度保証付き固有値と精度保証付き固有ベクトルを求めます。
   * 
   * @param A 固有値を求める区間行列
   */
  void solve(final CIM A);

      CM nan = IA.getMiddle().getElement(1).createGrid(value);
      CM nanL = xs.createZero(1, 1);
      nanL.setRowVector(1, nan);

      CM nanX = xs.createZero(IA.getRowSize(), 1);
      for (int i = 0; i < IA.getColumnSize(); i++) {
        nanX.setRowVector(i + 1, nanL);
      }

      L = createMidRad(nanL, nanL.getRealPart());
      X = createMidRad(nanX, nanX.getRealPart());

      System.err.println("no inclusion achieved"); //$NON-NLS-1$
      //throw new RuntimeException("no inclusion achieved"); //$NON-NLS-1$
    }

    manager.setRoundMode(oldRoundMode);
    CIM[] ans = (CIM[])new IntervalComplexNumericalMatrix[2];
    ans[0] = L;
    ans[1] = X;
    return ans;
  }

//  /**
//   * {@inheritDoc}
//   */
//  public void solveAsSparse(CM A) {
//    throw new UnsupportedOperationException();
//  }

  /**
   * {@inheritDoc}
   */
  public void solveAsSparse(CIM a) {

    return xyZeroMean.conjugateTranspose().multiply(xyZeroMean).divide(size - 1);
  }
  
  /**
   * 区間の中心を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param inf infimum
   * @param sup supremum
   * @return 区間の中心。
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CM middle(

  }
  
  /**
   * 区間の中心を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param inf infimum
   * @param sup supremum
   * @return 区間の中心。
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CM middle(

  }
  
  /**
   * 区間の半径を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param inf infimum
   * @param sup supremum
   * @return 区間の半径。
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM radius(CM inf, CM sup) {

  }

  /**
   * Creates interval matrix.
   * 
   * @param rs RS
   * @param ris RIS
   * @return RIM
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RIM create(

  }

  /**
   * 上限を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * 
   * @param mid middle
   * @param rad radius
   * @return 上限
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CS supremum(

  }

  /**
   * 区間行列Aが区間行列B内に含まれるかどうかを判定します。
   * 
   * @param A 区間
   * @param B 区間
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @return 区間に含まれる要素はtrue, 含まれない要素はfalse
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BooleanMatrix in0(

public class AnyIntervalDerivativeComplexMatrix<RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM> > extends AbstractIntervalDerivativeMatrix<AnyIntervalDerivativeComplexNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeComplexMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS, CIM, CS, CM> implements IntervalDerivativeComplexMatrix<AnyIntervalDerivativeRealNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeRealMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>,AnyIntervalDerivativeComplexNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeComplexMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>,RIS,RIM,CIS,CIM,RS,RM,CS,CM>{

public class AnyIntervalDerivativeComplexNumber<RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM> >  extends AbstractIntervalDerivativeNumber<AnyIntervalDerivativeComplexNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeComplexMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS, CIM, CS, CM> implements IntervalDerivativeComplexNumber<AnyIntervalDerivativeRealNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeRealMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>,AnyIntervalDerivativeComplexNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeComplexMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>,RIS,RIM,CIS,CIM,RS,RM,CS,CM>{

public abstract class AbstractIntervalComplexNumericalMatrix<RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>>
    extends AbstractIntervalNumericalMatrix<CIS, CIM, CS, CM> implements IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM> {

  }
  
  /**
   * 区間の中心を求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param inf infimum
   * @param sup supremum
   * @return 区間の中心。
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CM middle(

public interface IntervalComplexNumericalMatrix<RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends IntervalNumericalMatrix<CIS, CIM, CS, CM>, ComplexNumericalMatrix<RIS, RIM, CIS, CIM> {

public abstract class AbstractIntervalComplexNumericalScalar<RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>>
    extends AbstractIntervalScalar<CIS, CIM, CS, CM> implements IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM> {

public interface IntervalComplexNumericalScalar<RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends IntervalNumericalScalar<CIS,CIM,CS, CM>, ComplexNumericalScalar<RIS, RIM, CIS, CIM> {

public class ComplexIntlabMethod<RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>>
    implements LinearEquationVerifier<CIS, CIM, CS, CM> {

  }

  /**
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param A A
   * @param x x
   * @param b b
   * @return ?
   */
  private static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM residual(

public abstract class AbstractIntervalDerivativeComplexMatrix<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends AbstractIntervalDerivativeMatrix<CIDS, CIDM, CIS, CIM, CS, CM>

public abstract class AbstractIntervalDerivativeComplexNumber<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends AbstractIntervalDerivativeNumber<CIDS, CIDM, CIS, CIM, CS, CM>

  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> CM middle(

public class SequentialMethod<RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> {

  /** 任意の行列 */
  private RM matrix;

  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM radius(CM inf, CM sup) {

public abstract class AbstractIntervalDerivativeComplexMatrix<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends AbstractIntervalDerivativeMatrix<CIDS, CIDM, CIS, CIM, CS, CM>

public abstract class AbstractIntervalDerivativeComplexNumber<RIDS extends IntervalDerivativeRealNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIDM extends IntervalDerivativeRealMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDS extends IntervalDerivativeComplexNumber<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIDM extends IntervalDerivativeComplexMatrix<RIDS,RIDM,CIDS,CIDM,RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM>> extends AbstractIntervalDerivativeNumber<CIDS, CIDM, CIS, CIM, CS, CM>

public class AnyIntervalDerivativeComplexMatrix<RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM> > extends AbstractIntervalDerivativeMatrix<AnyIntervalDerivativeComplexNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeComplexMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS, CIM, CS, CM> implements IntervalDerivativeComplexMatrix<AnyIntervalDerivativeRealNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeRealMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>,AnyIntervalDerivativeComplexNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeComplexMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>,RIS,RIM,CIS,CIM,RS,RM,CS,CM>{

  public DoubleComplexIntervalMatrix subtractElementWise(final int y) {// ICM-R
    RoundModeManager manager = RoundModeManager.getManager();
    RoundMode oldRoundMode = manager.getRoundMode();

    manager.setRoundMode(RoundMode.ROUND_DOWN);
    DoubleComplexMatrix c1 = this.middle.subtractElementWise(y);

    manager.setRoundMode(RoundMode.ROUND_UP);
    DoubleComplexMatrix mid = this.middle.subtractElementWise(y);
    DoubleMatrix rad;
    if (isPointMatrix()) {
      rad = (mid.subtract(c1)).absElementWise().getRealPart();
    } else {
      rad = (mid.subtract(c1)).absElementWise().getRealPart().add(this.radius);
    }

    DoubleComplexIntervalMatrix ans = new DoubleComplexIntervalMatrix(mid, rad);
    manager.setRoundMode(oldRoundMode);
    return ans;
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalMatrix subtractElementWise(final double y) {// ICM-R

      CM nan = IA.getMiddle().getElement(1).createGrid(value);
      CM nanL = xs.createZero(1, 1);
      nanL.setRowVector(1, nan);

      CM nanX = xs.createZero(IA.getRowSize(), 1);
      for (int i = 0; i < IA.getColumnSize(); i++) {
        nanX.setRowVector(i + 1, nanL);
      }

      L = createMidRad(nanL, nanL.getRealPart());
      X = createMidRad(nanX, nanX.getRealPart());

      System.err.println("no inclusion achieved"); //$NON-NLS-1$
      //throw new RuntimeException("no inclusion achieved"); //$NON-NLS-1$
    }

    manager.setRoundMode(oldRoundMode);
    CIM[] ans = (CIM[])new IntervalComplexNumericalMatrix[2];
    ans[0] = L;
    ans[1] = X;
    return ans;
  }

        CM res = R.multiply(midb.unaryMinus().add(midA.multiply(localxs)));
        resnorm = (res).norm(NormType.TWO);

        if (resnorm.isLessThan(resnormold)) {
          localxs = localxs.subtract(res);
        }

        // TODO 精度に影響しない？
        if (resnorm.isLessThanOrEquals(resnormold.multiply(1e-1))) {// beware of zero residual
          break;
        }
      }

    } else {
      localxs = localxs.add(R.multiply(midb.subtract(midA.multiply(localxs))));
    }

    List<Object> list = new ArrayList<>();
    list.add(localxs);
    list.add(Boolean.valueOf(improvedresidual));
    return list;
  }

  /**
   * intbalMethod内で使用する計算。
   * 
   * @param ires ires
   * @param Z Z
   * @param RA RA
   * @param R R
   * @param xs xs
   * @param n n
   * @param k k
   * @return result
   */
  private CIM stage12(CIM ires, CIM Z, CIM RA, CM R, CM xs, int n, int k) {

  public void setElement(final int index, final CIS value) {
    this.middle.setElement(index, value.getMiddle());
    this.radius.setElement(index, value.getRadius());
    updateInfinumSupremum();
  }

  /**
   * {@inheritDoc}
   */
  public void setElement(int row, int column, int value) {
    this.middle.setElement(row, column, value);
    this.radius.setElement(row, column, 0);
    updateInfinumSupremum();
  }

  /**
   * {@inheritDoc}
   */
  public void setElement(int row, int column, double value) {
    this.middle.setElement(row, column, value);
    this.radius.setElement(row, column, 0);
    updateInfinumSupremum();
  }

  /**
   * @param row row
   * @param column column
   * @param value value
   */
  public void setElement(int row, int column, CS value) {

        ElementHolder<?> list = ((EV.getValue().diagonalToVector()).absElementWise()).maximum();
        int index = list.getRow();

        CM Perronx = EV.getVector().getColumnVector(index);

        manager.setRoundMode(RoundMode.ROUND_UP);

        /* upper bound for Perron root */
        RM rad = ((M.toComplex().multiply(Perronx).divideElementWise(Perronx))).maxColumnWise().getRealPart();

        manager.setRoundMode(RoundMode.ROUND_NEAR);
        CS[] value = locallambda.createArray(1);
        value[0] = locallambda;
        CM mid = locallambda.createGrid(value);
        L = createMidRad(mid, rad);
      }

      IY.setRowVectors(v, IY.createZero(v.getColumnSize(), IY.getColumnSize()));

  public DoubleComplexIntervalMatrix addElementWise(final int y) {
    RoundModeManager manager = RoundModeManager.getManager();
    RoundMode oldRoundMode = manager.getRoundMode();

    manager.setRoundMode(RoundMode.ROUND_DOWN);
    DoubleComplexMatrix c1 = this.middle.addElementWise(y);

    manager.setRoundMode(RoundMode.ROUND_UP);
    DoubleComplexMatrix mid = this.middle.addElementWise(y);
    DoubleMatrix rad;
    if (isPointMatrix()) {
      rad = (mid.subtract(c1)).absElementWise().getRealPart();
    } else {
      rad = (mid.subtract(c1)).absElementWise().getRealPart().add(this.radius);
    }

    AnyIntervalDerivativeComplexNumber<RIS, RIM, CIS, CIM, RS, RM, CS, CM>[][] elements = getElement(1, 1).createArray(matrix.getRowSize(), matrix.getColumnSize());
    for (int i = 0; i < matrix.getRowSize(); i++) {
      for (int j = 0; j < matrix.getColumnSize(); j++) {
        elements[i][j] = getElement(1,1).create(matrix.getElement(i+1,j+1));
      }
    }
    return new AnyIntervalDerivativeComplexMatrix<>(elements);

      CIM C = im.create(xs.createUnit(n)).subtract(R.multiply(Iy_dx));

      int i = 0;
      // improved interval iteration
      while (!ready && i < 2) {
        i = i + 1;
        X = Z.add(C.multiply(Y));
        ready = IntervalUtil.in0forRump(X, Y).allTrue();
        Y = IntervalUtil.intersect(X, Yold);
      }
    }

    if (ready) {
      X = Y.add(im.create(xss));
    } else {
      throw new IllegalArgumentException();
      // TODO 例外投げるか、NaNを返すようにする
    }

    return X;
  }

  /**
   * 非線型方程式の解を精度保証付きで求めます。
   * 
   * <p>初期値区間に真の解が含まれる場合、非線形方程式の真の解を含むより小さな区間を返します。
   * 
   * @param xs 初期値区間
   * @param idm idm
   * @return 非線形方程式の解
   */
  public CIM solve(CIM xs, CIDM idm) {

    CS unit1 = sparseVectorFi[0][0].createUnit();
    int p = 0;
    for(int i = 0; i < sparseVectorFi.length; i++) {
      for (int j = 0; j < sparseVectorFi[0].length; j++) {
        if (sparseVectorFi[i][j].abs().equals(unit1) || sparseVectorFi[i][j].abs().equals(unit1.multiply(2))) {
          I[p] = j+1;
          p++;
          break;
        }
      }
    }
    return I;
  }
}

    S[] d2 = unit.createArray(M.length());

    for (int i = 0; i < D.length(); i++) {
      d1[i] = D.getElement(i + 1, 1);
      d2[i] = M.getElement(i + 1, 1);
    }

    Ac = Ac.subtract(d1[0].createGrid(d1).vectorToDiagonal()).add(d2[0].createGrid(d2).vectorToDiagonal());
    return Ac;
  }

  /**
   * Comparison Matrixを求めます。
   * 
   * @param <RIS> 実区間スカラーの型
   * @param <RIM> 実区間行列の型
   * @param <CIS> 複素区間スカラーの型
   * @param <CIM> 複素区間行列の型
   * @param <RS> 実スカラーの型
   * @param <RM> 実行列の型
   * @param <CS> 複素スカラーの型
   * @param <CM> 複素行列の型
   * @param im 区間行列
   * @return ComparisonMatrix
   */
  public static <RIS extends IntervalRealNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RIM extends IntervalRealNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIS extends IntervalComplexNumericalScalar<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, CIM extends IntervalComplexNumericalMatrix<RIS, RIM, CIS, CIM, RS, RM, CS, CM>, RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RM comparisonMatrix(

    CS[] d2 = rUnit.createArray(M.length());

    for (int i = 0; i < D.length(); i++) {
      d1[i] = D.getElement(i + 1, 1);
      d2[i] = M.getElement(i + 1, 1);
    }

    Ac = Ac.subtract(d1[0].createGrid(d1).vectorToDiagonal()).add(d2[0].createGrid(d2).vectorToDiagonal());
    return Ac;
  }

  /**
   * {@inheritDoc}
   */
  public CM abssElementWise() {

public class AnyIntervalDerivativeComplexMatrix<RIS extends IntervalRealNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RIM extends IntervalRealNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS extends IntervalComplexNumericalScalar<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIM extends IntervalComplexNumericalMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, RS extends RealNumericalScalar<RS,RM,CS,CM>, RM extends RealNumericalMatrix<RS,RM,CS,CM>, CS extends ComplexNumericalScalar<RS,RM,CS,CM>, CM extends ComplexNumericalMatrix<RS,RM,CS,CM> > extends AbstractIntervalDerivativeMatrix<AnyIntervalDerivativeComplexNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeComplexMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, CIS, CIM, CS, CM> implements IntervalDerivativeComplexMatrix<AnyIntervalDerivativeRealNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeRealMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>,AnyIntervalDerivativeComplexNumber<RIS,RIM,CIS,CIM,RS,RM,CS,CM>, AnyIntervalDerivativeComplexMatrix<RIS,RIM,CIS,CIM,RS,RM,CS,CM>,RIS,RIM,CIS,CIM,RS,RM,CS,CM>{

  /** */
  private static final long serialVersionUID = 1L;

  /**
   * Creates {@link AnyIntervalDerivativeComplexMatrix}.
   * @param elements elements
   */
  public AnyIntervalDerivativeComplexMatrix(AnyIntervalDerivativeComplexNumber<RIS, RIM, CIS, CIM, RS, RM, CS, CM>[] elements) {

  private void updateMiddleRadius() {
    this.middle = mid(this.infimum, this.supremum);
    this.radius = rad(this.middle, this.infimum);
  }

  /**
   * 要素に区間内の浮動小数点数の個数を持つ整数行列を返します。
   * 
   * @return 要素に区間内の浮動小数点数の個数を持つ整数行列
   */
  public long[][] getPointsNumber() {
    long[][] count = new long[getRowSize()][getColumnSize()];

    for (int row = 0; row < getRowSize(); row++) {
      for (int column = 0; column < getColumnSize(); column++) {
        count[row][column] = ((DoubleIntervalNumber)getElement((row + 1) * (column + 1))).getPointsNumber();