DoubleComplexIntervalNumber.java

/*
 * Created on 2004/08/05
 *
 * $Id: ComplexInterval.java,v 1.39 2008/04/23 09:43:20 yano Exp $
 * Copyright (C) 2004 Koga Laboratory. All rights reserved.
 */
package org.mklab.cga.interval.scalar;

import org.mklab.cga.interval.matrix.DoubleComplexIntervalMatrix;
import org.mklab.cga.interval.matrix.DoubleIntervalMatrix;
import org.mklab.nfc.matrix.DoubleComplexMatrix;
import org.mklab.nfc.matrix.DoubleMatrix;
import org.mklab.nfc.scalar.DoubleComplexNumber;
import org.mklab.nfc.scalar.DoubleNumber;

/**
 * 倍精度の複素数の区間を表すクラスです。
 * 
 * @author hiroki
 * @version $Revision: 1.39 $. 2004/08/05
 */
public class DoubleComplexIntervalNumber extends AbstractIntervalComplexNumericalScalar<DoubleIntervalNumber,DoubleIntervalMatrix,DoubleComplexIntervalNumber,DoubleComplexIntervalMatrix,DoubleNumber,DoubleMatrix,DoubleComplexNumber,DoubleComplexMatrix>{

  /** シリアル番号 */
  private static final long serialVersionUID = -6325124450882844434L;

//  /** 区間の下限 */
//  private DoubleComplexNumber infimum;
//
//  /** 区間の上限 */
//  private DoubleComplexNumber supremum;
//
//  /** 区間の中心 */
//  private DoubleComplexNumber middle;
//
//  /** 区間の半径 */
//  private DoubleComplexNumber radius;
  
  /**
   * Creates {@link DoubleComplexIntervalNumber}.
   * @param middle middle
   * @param radius radius
   */
  public DoubleComplexIntervalNumber(DoubleComplexNumber middle, DoubleNumber radius) {
    super(middle, radius);
  }

  /**
   * Creates {@link DoubleComplexIntervalNumber}.
   * @param infimum infimum
   * @param supremum supremum
   */
  public DoubleComplexIntervalNumber(DoubleComplexNumber infimum, DoubleComplexNumber supremum) {
    super(middle(infimum, supremum), radius(infimum, supremum));
  }

  /**
   * 区間を作成します。複素数の中心を設定します。
   * 
   * @param middle 中心
   */
  public DoubleComplexIntervalNumber(final DoubleComplexNumber middle) {
    super(middle);
  }

  /**
   * 区間を作成します。複素数の中心と半径を設定します。
   * 
   * @param middle 中心
   * @param radius 半径
   */
  public DoubleComplexIntervalNumber(final DoubleComplexNumber middle, final double radius) {
    super(middle, new DoubleNumber(radius));
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalNumber createMidRad(DoubleComplexNumber middle, DoubleNumber radius) {
    return new DoubleComplexIntervalNumber(middle,radius);
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalNumber create(DoubleComplexNumber value) {
    return new DoubleComplexIntervalNumber(value);
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalNumber createInfSup(DoubleComplexNumber infimum, DoubleComplexNumber supremum) {
    return new DoubleComplexIntervalNumber(middle(infimum, supremum), radius(infimum, supremum));
  }

  /**
   * Creates interval
   * 
   * @param infimum infimum
   * @param supremum supremum
   * @return interval
   */
  public static DoubleComplexIntervalNumber createInfimumSuppremum(DoubleComplexNumber infimum, DoubleComplexNumber supremum) {
    return new DoubleComplexIntervalNumber(middle(infimum, supremum), radius(infimum, supremum));
  }

  /**
   * Creates interval
   * 
   * @param middle middle
   * @param radius radius
   * @return interval
   */
  public static DoubleComplexIntervalNumber createMiddleRadius(DoubleComplexNumber middle, DoubleNumber radius) {
    return new DoubleComplexIntervalNumber(middle,radius);
  }


  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalNumber create(double value) {
    return new DoubleComplexIntervalNumber(new DoubleComplexNumber(value));
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalNumber[] createArray(int size) {
    return new DoubleComplexIntervalNumber[size];
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalNumber[][] createArray(int rowSize, int columnSize) {
    return new DoubleComplexIntervalNumber[rowSize][columnSize];
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalNumber createImaginaryUnit() {
    return new DoubleComplexIntervalNumber(new DoubleComplexNumber(0,1));
  }

  /**
   * {@inheritDoc}
   */
  public DoubleIntervalNumber createInfSup(DoubleNumber infimum, DoubleNumber supremum) {
    return DoubleIntervalNumber.createInfimumSupremum(infimum, supremum);
  }

  /**
   * {@inheritDoc}
   */
  public DoubleIntervalNumber createMidRad(DoubleNumber middle, DoubleNumber radius) {
    return DoubleIntervalNumber.createMiddleRadius(middle, radius);
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalMatrix createGrid(int rowSize, int columnSize, DoubleComplexIntervalNumber[][] elements) {
    return new DoubleComplexIntervalMatrix(elements);
  }

  /**
   * {@inheritDoc}
   */
  public DoubleComplexIntervalMatrix createGrid(DoubleComplexIntervalNumber[] elements) {
    return new DoubleComplexIntervalMatrix(elements);
  }

//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexNumber getInfimum() {
//    return this.infimum;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexNumber getSupremum() {
//    return this.supremum;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexNumber getMiddle() {
//    return this.middle;
//  }

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


//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber create(final int value) {
//    return new DoubleComplexIntervalNumber(new DoubleComplexNumber(value, 0));
//  }
//
//  /**
//   * @see org.mklab.cga.interval.scalar.IntervalScalar#add(org.mklab.cga.interval.scalar.IntervalScalar)
//   */
//  public DoubleComplexIntervalNumber add(final IntervalScalar<?> interval) {// IC+IR, IC+IC
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber c1 = (DoubleComplexNumber)this.middle.add(interval.getMiddle());
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber mid = (DoubleComplexNumber)this.middle.add(interval.getMiddle());
//
//    double rad = mid.subtract(c1).abs().doubleValue() + this.radius + ((DoubleNumber)interval.getRadius()).doubleValue();
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber add(final double d) {// IC+R
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber c1 = this.middle.add(d);
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber mid = this.middle.add(d);
//
//    double rad = mid.subtract(c1).abs().doubleValue() + this.radius;
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber add(final DoubleComplexNumber c) {// IC+C
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber c1 = this.middle.add(c);
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber mid = this.middle.add(c);
//
//    double rad = mid.subtract(c1).abs().doubleValue() + this.radius;
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber subtract(final DoubleComplexIntervalNumber interval) {// IC-IR, IC-IC
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber c1 = (DoubleComplexNumber)this.middle.subtract(interval.getMiddle());
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber mid = (DoubleComplexNumber)this.middle.subtract(interval.getMiddle());
//
//    double rad = mid.subtract(c1).abs().doubleValue() + this.radius + ((DoubleNumber)interval.getRadius()).doubleValue();
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber subtract(final double d) {// IC-R
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber c1 = this.middle.subtract(d);
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber mid = this.middle.subtract(d);
//
//    double rad = mid.subtract(c1).abs().doubleValue() + this.radius;
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber subtract(final DoubleComplexNumber c) {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber c1 = this.middle.subtract(c);
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber mid = this.middle.subtract(c);
//
//    double rad = mid.subtract(c1).abs().doubleValue() + this.radius;
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber multiply(final DoubleComplexIntervalNumber interval) {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    double a_mid_real = this.middle.getRealPart().doubleValue();
//    double a_mid_imag = this.middle.getImaginaryPart().doubleValue();
//
//    double b_mid_real = ((DoubleNumber)interval.getMiddle().getRealPart()).doubleValue();
//    double b_mid_imag = ((DoubleNumber)interval.getMiddle().getImaginaryPart()).doubleValue();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//
//    double c1_real = a_mid_real * b_mid_real + (-a_mid_imag) * b_mid_imag;
//    double c1_imag = a_mid_real * b_mid_imag + a_mid_imag * b_mid_real;
//    DoubleComplexNumber c1 = new DoubleComplexNumber(c1_real, c1_imag);
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//
//    double c2_real = a_mid_real * b_mid_real + (-a_mid_imag) * b_mid_imag;
//    double c2_imag = a_mid_real * b_mid_imag + a_mid_imag * b_mid_real;
//    DoubleComplexNumber c2 = new DoubleComplexNumber(c2_real, c2_imag);
//
//    DoubleComplexNumber mid = c1.add(c2.subtract(c1).divide(2));
//    double rad;
//
//    if (this.radius == 0) {
//      if (interval.getRadius().isZero()) {
//        rad = mid.subtract(c1).abs().doubleValue();
//      } else {
//        rad = mid.subtract(c1).abs().doubleValue() + this.middle.abs().doubleValue() + ((DoubleNumber)interval.getRadius()).doubleValue();
//      }
//    } else if (interval.getRadius().isZero()) {
//      rad = mid.subtract(c1).abs().doubleValue() + this.radius * ((DoubleNumber)interval.getMiddle().abs()).doubleValue();
//    } else {
//      rad = mid.subtract(c1).abs().doubleValue() + this.radius * (((DoubleNumber)interval.getMiddle().abs()).doubleValue() + ((DoubleNumber)interval.getRadius()).doubleValue())
//          + this.middle.abs().doubleValue() * ((DoubleNumber)interval.getRadius()).doubleValue();
//    }
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber multiply(final double d) {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber c1 = this.middle.multiply(d);
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber c2 = this.middle.multiply(d);
//
//    DoubleComplexNumber mid = c1.add(c2.subtract(c1).divide(2));
//
//    double rad = mid.subtract(c1).abs().doubleValue() + this.radius * Math.abs(d);
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber multiply(final DoubleComplexNumber c) {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    double a_mid_real = this.middle.getRealPart().doubleValue();
//    double a_mid_imag = this.middle.getImaginaryPart().doubleValue();
//
//    double b_mid_real = c.getRealPart().doubleValue();
//    double b_mid_imag = c.getImaginaryPart().doubleValue();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//
//    double c1_real = a_mid_real * b_mid_real + (-a_mid_imag) * b_mid_imag;
//    double c1_imag = a_mid_real * b_mid_imag + a_mid_imag * b_mid_real;
//
//    DoubleComplexNumber c1 = new DoubleComplexNumber(c1_real, c1_imag);
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//
//    double c2_real = a_mid_real * b_mid_real + (-a_mid_imag) * b_mid_imag;
//    double c2_imag = a_mid_real * b_mid_imag + a_mid_imag * b_mid_real;
//
//    DoubleComplexNumber c2 = new DoubleComplexNumber(c2_real, c2_imag);
//
//    DoubleComplexNumber mid = c1.add(c2.subtract(c1).divide(2));
//
//    double rad = mid.subtract(c1).abs().doubleValue() + this.radius * c.abs().doubleValue();
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber sqrt() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber l = this.infimum.sqrt();
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber s = this.supremum.sqrt();
//
//    DoubleComplexNumber mid = l.add((s.subtract(l)).divide(2));
//    double rad = mid.subtract(l).abs().doubleValue();
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(mid, rad);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public double mig() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//
//    double c = this.middle.abs().doubleValue() - this.radius;
//
//    if (c >= 0) {
//      c = c * 1;
//    } else {
//      c = c * 0;
//    }
//
//    manager.setRoundMode(oldRoundMode);
//    return c;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber unaryMinus() {
//    return new DoubleComplexIntervalNumber(this.middle.unaryMinus(), this.radius);
//  }
//
//  /**
//   * 逆数を求めます。
//   * 
//   * @return 複素区間の逆数。
//   */
//  /*
//   * public ComplexInterval inverse() { ComplexInterval numerator =
//   * this.conjugate(); ComplexInterval denominator = this.multiply(numerator);
//   * 
//   * double numerator_upper_real = numerator.getUpper().getRealPart(); double
//   * numerator_lower_real = numerator.getLower().getRealPart(); double
//   * numerator_upper_imag = numerator.getUpper().getImagPart(); double
//   * numerator_lower_imag = numerator.getLower().getImagPart();
//   * 
//   * double denominator_upper = denominator.getUpper().getRealPart(); double
//   * denominator_lower = denominator.getLower().getRealPart();
//   * 
//   * RealInterval numerator_realPart = new RealInterval( numerator_lower_real,
//   * numerator_upper_real); RealInterval numerator_imagPart = new RealInterval(
//   * numerator_lower_imag, numerator_upper_imag);
//   * 
//   * RealInterval denominator_realPart = new RealInterval(denominator_lower,
//   * denominator_upper); //System.out.println("分子実部");
//   * //numerator_realPart.print(); //System.out.println("分母虚部");
//   * //numerator_realPart.print(); //System.out.println("分母実部");
//   * //denominator_realPart.print();
//   * 
//   * RealInterval realPart = numerator_realPart.divide(denominator_realPart);
//   * RealInterval imagPart = numerator_imagPart.divide(denominator_realPart);
//   * //System.out.println("実部"); //realPart.print(); //System.out.println("虚部");
//   * //imagPart.print();
//   * 
//   * Complex lower = new Complex(realPart.getLower(), imagPart.getLower());
//   * Complex upper = new Complex(realPart.getUpper(), imagPart.getUpper());
//   * 
//   * return new ComplexInterval(lower, upper); }
//   */
//
//  /**
//   * 複素共役数を求めます。
//   * 
//   * @return 複素共役数
//   */
//  /*
//   * public ComplexInterval conjugate() { Complex inf_conjugate =
//   * this.inf.conjugate(); Complex sup_conjugate = this.sup.conjugate();
//   * 
//   * double lower_conjugate_real = inf_conjugate.getRealPart(); double
//   * lower_conjugate_imag = inf_conjugate.getImagPart(); double
//   * upper_conjugate_real = sup_conjugate.getRealPart(); double
//   * upper_conjugate_imag = sup_conjugate.getImagPart();
//   * 
//   * Complex inf = new Complex(lower_conjugate_real, upper_conjugate_imag);
//   * Complex sup = new Complex(upper_conjugate_real, lower_conjugate_imag);
//   * 
//   * return new ComplexInterval(inf, sup); }
//   */
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexNumber getError() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber error = this.supremum.subtract(this.infimum);
//
//    manager.setRoundMode(oldRoundMode);
//    return error;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void printInterval() {
//    printInterval("ans"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void printInterval(final String name) {
//    System.out.println(name + "(infimum,supremum) = [" + this.infimum + ", " + this.supremum + "]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void printMidRad() {
//    printMidRad("ans"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void printMidRad(final String name) {
//    System.out.println(name + "(middle,radius) = <" + this.middle + ", " + this.radius + ">"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void printInfSup() {
//    printInfSup("ans"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void printInfSup(final String name) {
//    this.infimum.print(name + Messages.getString("ComplexInterval.0")); //$NON-NLS-1$
//    this.supremum.print(name + Messages.getString("ComplexInterval.1")); //$NON-NLS-1$
//  }
//
//  /**
//   * 下限を求めます。
//   * 
//   * @return 下限
//   */
//  private DoubleComplexNumber inf() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    double real = this.middle.getRealPart().doubleValue() - this.radius;
//    double imag = this.middle.getImaginaryPart().doubleValue() - this.radius;
//    DoubleComplexNumber inf = new DoubleComplexNumber(real, imag);
//
//    manager.setRoundMode(oldRoundMode);
//    return inf;
//  }
//
//  /**
//   * 上限を求めます。
//   * 
//   * @return 上限
//   */
//  private DoubleComplexNumber sup() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    double real = this.middle.getRealPart().doubleValue() + this.radius;
//    double imag = this.middle.getImaginaryPart().doubleValue() + this.radius;
//    DoubleComplexNumber sup = new DoubleComplexNumber(real, imag);
//
//    manager.setRoundMode(oldRoundMode);
//    return sup;
//  }
//
//  /**
//   * 区間の中心を求めます。
//   * 
//   * @return 区間の中心。
//   */
//  private DoubleComplexNumber mid() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber mid = this.infimum.add(this.supremum.subtract(this.infimum).divide(2));
//
//    manager.setRoundMode(oldRoundMode);
//    return mid;
//  }
//
//  /**
//   * 区間の半径を求めます。
//   * 
//   * @return 区間の半径。
//   */
//  private double rad() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber mid = mid();
//    double rad = mid.subtract(this.infimum).abs().doubleValue();
//
//    manager.setRoundMode(oldRoundMode);
//    return rad;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber divide(DoubleComplexIntervalNumber i) {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void printInfSupByBit(String name) {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber add(int value) {
//    return new DoubleComplexIntervalNumber(this.infimum.add(value), this.supremum.add(value));
//  }
//
//  //  /**
//  //   * @see org.mklab.nfc.scalar.Scalar#addSelf(org.mklab.nfc.scalar.Scalar)
//  //   */
//  //  public Scalar<?> addSelf(Scalar<?> value) {
//  //    RoundModeManager manager = RoundModeManager.getManager();
//  //    RoundMode oldRoundMode = manager.getRoundMode();
//  //    
//  //    manager.setRoundMode(RoundMode.ROUND_DOWN);
//  //    DoubleComplexNumber c1 = this.middle.add(((DoubleComplexIntervalNumber)value).getMiddle());
//  //
//  //    manager.setRoundMode(RoundMode.ROUND_UP);
//  //    DoubleComplexNumber mid = this.middle.add(((DoubleComplexIntervalNumber)value).getMiddle());
//  //    
//  //    double rad = mid.subtract(c1).abs().doubleValue();
//  //    rad = rad + this.radius;
//  //    rad = rad + ((DoubleComplexIntervalNumber)value).getRadius().doubleValue();
//  //
//  //    manager.setRoundMode(oldRoundMode);
//  //    return new DoubleComplexIntervalNumber(mid, rad);
//  //  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean compare(String operator, int opponent) {
//    if (operator.equals(".!=")) { //$NON-NLS-1$
//      if (this.infimum.getRealPart().equals(new DoubleNumber(opponent)) && this.infimum.getImaginaryPart().isZero() && this.supremum.getRealPart().equals(new DoubleNumber(opponent))
//          && this.supremum.getImaginaryPart().isZero()) {
//        return false;
//      }
//    } else if (operator.equals(".==")) { //$NON-NLS-1$
//      if (this.infimum.getRealPart().equals(new DoubleNumber(opponent)) == false || this.infimum.getImaginaryPart().isZero() == false
//          && this.supremum.getRealPart().equals(new DoubleNumber(opponent)) == false || this.supremum.getImaginaryPart().isZero() == false) {
//        return false;
//      }
//    } else if (operator.equals(".<")) { //$NON-NLS-1$
//      // TODO 実装して実行できるようにする
//      // return isLessThan(opponent);
//      throw new UnsupportedOperationException();
//    } else if (operator.equals(".<=")) { //$NON-NLS-1$
//      // TODO 実装して実行できるようにする
//      // return isLessThanOrEquals(opponent);
//      throw new UnsupportedOperationException();
//    } else if (operator.equals(".>")) { //$NON-NLS-1$
//      // TODO 実装して実行できるようにする
//      // return isGreaterThan(opponent);
//      throw new UnsupportedOperationException();
//    } else if (operator.equals(".>=")) { //$NON-NLS-1$
//      // TODO 実装して実行できるようにする
//      // return isGreaterThanOrEquals(opponent);
//      throw new UnsupportedOperationException();
//    } else {
//      throw new UnsupportedOperationException();
//    }
//
//    return true;
//
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean compare(String operator, double opponent) {
//    if (operator.equals(".!=")) { //$NON-NLS-1$
//      if (this.infimum.getRealPart().equals(new DoubleNumber(opponent)) && this.infimum.getImaginaryPart().isZero() && this.supremum.getRealPart().equals(new DoubleNumber(opponent))
//          && this.supremum.getImaginaryPart().isZero()) {
//        return false;
//      }
//    } else if (operator.equals(".==")) { //$NON-NLS-1$
//      if (this.infimum.getRealPart().equals(new DoubleNumber(opponent)) == false || this.infimum.getImaginaryPart().isZero() == false
//          && this.supremum.getRealPart().equals(new DoubleNumber(opponent)) == false || this.supremum.getImaginaryPart().isZero() == false) {
//        return false;
//      }
//    } else if (operator.equals(".<")) { //$NON-NLS-1$
//      // TODO 実装して実行できるようにする
//      // return isLessThan(opponent);
//      throw new UnsupportedOperationException();
//    } else if (operator.equals(".<=")) { //$NON-NLS-1$
//      // TODO 実装して実行できるようにする
//      // return isLessThanOrEquals(opponent);
//      throw new UnsupportedOperationException();
//    } else if (operator.equals(".>")) { //$NON-NLS-1$
//      // TODO 実装して実行できるようにする
//      // return isGreaterThan(opponent);
//      throw new UnsupportedOperationException();
//    } else if (operator.equals(".>=")) { //$NON-NLS-1$
//      // TODO 実装して実行できるようにする
//      // return isGreaterThanOrEquals(opponent);
//      throw new UnsupportedOperationException();
//    } else {
//      throw new UnsupportedOperationException();
//    }
//
//    return true;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber conjugate() {
//    return new DoubleComplexIntervalNumber(this.middle.conjugate(), this.radius);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalMatrix createGrid(int rowSize, int columnSize, DoubleComplexIntervalNumber[][] elements) {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalMatrix createGrid(DoubleComplexIntervalNumber[] elements) {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber createUnit() {
//    return new DoubleComplexIntervalNumber(this.middle.createUnit(), 0);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber divide(int value) {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber divide(double value) {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean equals(DoubleComplexIntervalNumber opponent, double tolerance) {
//    final boolean realEquals = this.infimum.getRealPart().equals(opponent.getInfimum().getRealPart(), tolerance) && this.supremum.getRealPart().equals(opponent.getSupremum().getRealPart(), tolerance);
//    final boolean imagEquals = this.infimum.getImaginaryPart().equals(opponent.getInfimum().getImaginaryPart(), tolerance)
//        && this.infimum.getImaginaryPart().equals(opponent.getSupremum().getImaginaryPart(), tolerance);
//    return realEquals && imagEquals;
//  }
//
//  //  /**
//  //   * @see org.mklab.nfc.scalar.Scalar#equals(org.mklab.nfc.scalar.Scalar, double)
//  //   */
//  //  @Override
//  //  public boolean equals(Scalar<?> opponent, double tolerance) {
//  //    if (opponent instanceof DoubleComplexIntervalNumber) {
//  //      return equals((DoubleComplexIntervalNumber)opponent, tolerance);
//  //    }
//  //    return super.equals(opponent, tolerance);
//  //  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleIntervalNumber getImaginaryPart() {
//    return new DoubleIntervalNumber(this.infimum.getImaginaryPart().doubleValue(), this.supremum.getImaginaryPart().doubleValue());
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleIntervalNumber getRealPart() {
//    return new DoubleIntervalNumber(this.infimum.getRealPart().doubleValue(), this.supremum.getRealPart().doubleValue());
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void setRealPart(int realPart) {
//    this.middle.setRealPart(realPart);
//    this.infimum = inf();
//    this.supremum = sup();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void setRealPart(double realPart) {
//    this.middle.setRealPart(realPart);
//    this.infimum = inf();
//    this.supremum = sup();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void setRealPart(DoubleIntervalNumber realPart) {
//    if (realPart instanceof DoubleNumber) {
//      this.middle.setRealPart(realPart);
//      this.infimum = inf();
//      this.supremum = sup();
//    }
//    throw new UnsupportedOperationException("Not appropriate date type"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void setImaginaryPart(int imagPart) {
//    this.middle.setImaginaryPart(imagPart);
//    this.infimum = inf();
//    this.supremum = sup();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void setImaginaryPart(double imagPart) {
//    this.middle.setImaginaryPart(imagPart);
//    this.infimum = inf();
//    this.supremum = sup();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void setImaginaryPart(DoubleIntervalNumber imagPart) {
//    if (imagPart instanceof DoubleNumber) {
//      this.middle.setImaginaryPart(imagPart);
//      this.infimum = inf();
//      this.supremum = sup();
//    }
//    throw new UnsupportedOperationException("Not appropriate date type"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber inverse() {
//    DoubleComplexIntervalNumber conj = this.conjugate();
//    DoubleIntervalNumber den = this.multiply(conj).getRealPart();
//    final DoubleIntervalNumber realPart = conj.getRealPart().divide(den);
//    final DoubleIntervalNumber imagPart = conj.getImaginaryPart().divide(den);
//    DoubleComplexNumber inf = new DoubleComplexNumber(realPart.getInfimum().doubleValue(), imagPart.getInfimum().doubleValue());
//    DoubleComplexNumber sup = new DoubleComplexNumber(realPart.getSupremum().doubleValue(), imagPart.getSupremum().doubleValue());
//    return new DoubleComplexIntervalNumber(inf, sup);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isComplex() {
//    return true;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isInfinite() {
//    return this.infimum.isInfinite() && this.supremum.isInfinite();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isNaN() {
//    return this.infimum.isNaN() && this.supremum.isNaN();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isReal() {
//    return false;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isUnit() {
//    return this.infimum.isUnit() && this.supremum.isUnit();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isUnit(double tolerance) {
//    return this.infimum.isUnit(tolerance) && this.supremum.isUnit(tolerance);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isUnit(DoubleComplexIntervalNumber tolerance) {
//    return this.infimum.isUnit(tolerance) && this.supremum.isUnit(tolerance);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isZero(double tolerance) {
//    return this.infimum.isZero() && this.supremum.isZero();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isZero(DoubleComplexIntervalNumber tolerance) {
//    return this.infimum.isZero() && this.supremum.isZero();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber leftDivide(int value) {
//    return this.inverse().multiply(value);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber leftDivide(double value) {
//    return this.inverse().multiply(value);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber multiply(int value) {
//    return new DoubleComplexIntervalNumber(this.middle.multiply(value), this.radius);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber power(int scalar) {
//    // TODO 絶対値と角度の形式に書き直す
//    DoubleComplexIntervalNumber value = (DoubleComplexIntervalNumber)this.clone();
//    for (int i = 0; i < scalar; i++) {
//      value = value.multiply(value);
//    }
//    return value;
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber subtract(int value) {
//    return new DoubleComplexIntervalNumber(this.infimum.subtract(value), this.supremum.subtract(value));
//  }
//
////  /**
////   * @see org.mklab.nfc.scalar.Scalar#toComplex()
////   */
////  public DoubleComplexIntervalNumber toComplex() {
////    return (DoubleComplexIntervalNumber)this.clone();
////  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public String toString(String valueFormat) {
//    // TODO 下限と上限もメソッド呼び出した方がいい？
//    return String.format("(" + valueFormat + "," + valueFormat + ")", this.infimum, this.supremum); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber[] createArray(int size) {
//    return new DoubleComplexIntervalNumber[size];
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber[][] createArray(int rowSize, int columnSize) {
//    return new DoubleComplexIntervalNumber[rowSize][columnSize];
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber createZero() {
//    return new DoubleComplexIntervalNumber(this.infimum.createZero());
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isZero() {
//    return this.infimum.isZero() && this.supremum.isZero();
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber ceil() {
//    return new DoubleComplexIntervalNumber(this.infimum.ceil(), this.supremum.ceil());
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber fix() {
//    return new DoubleComplexIntervalNumber(this.infimum.fix(), this.supremum.fix());
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber floor() {
//    return new DoubleComplexIntervalNumber(this.infimum.floor(), this.supremum.floor());
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber round() {
//    return new DoubleComplexIntervalNumber(this.infimum.round(), this.supremum.round());
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber roundToZero(double tolerance) {
//    return new DoubleComplexIntervalNumber(this.infimum.roundToZero(tolerance), this.supremum.roundToZero(tolerance));
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber roundToZero(DoubleComplexIntervalNumber tolerance) {
//    return new DoubleComplexIntervalNumber(this.infimum.roundToZero(tolerance), this.supremum.roundToZero(tolerance));
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber abs() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    double abs = this.middle.abs().doubleValue();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    double inf = abs + this.radius;
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    double sup = abs + this.radius;
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleIntervalNumber(inf, sup);
//  }
//
//  // TODO 三角関数の逆関数をちゃんとした精度保証付きで実装する
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber acos() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber inf = this.infimum.acos();
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber sup = this.supremum.acos();
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(inf, sup);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber asin() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber inf = this.infimum.asin();
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber sup = this.supremum.asin();
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(inf, sup);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber atan() {
//    RoundModeManager manager = RoundModeManager.getManager();
//    RoundMode oldRoundMode = manager.getRoundMode();
//
//    manager.setRoundMode(RoundMode.ROUND_DOWN);
//    DoubleComplexNumber inf = this.infimum.atan();
//
//    manager.setRoundMode(RoundMode.ROUND_UP);
//    DoubleComplexNumber sup = this.supremum.atan();
//
//    manager.setRoundMode(oldRoundMode);
//    return new DoubleComplexIntervalNumber(inf, sup);
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber exp() {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber log() {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public DoubleComplexIntervalNumber sqr() {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public void printInfSupByBit() {
//    throw new RuntimeException("Not implemented"); //$NON-NLS-1$
//  }
//
//  /**
//   * {@inheritDoc}
//   */
//  public boolean isPointScalar() {
//    return this.radius == 0;
//  }
}