Restrictor.java
/*
* Created on 2007/02/02
* Copyright (C) 2007 Koga Laboratory. All rights reserved.
*
*/
package org.mklab.tool.control.system.sink;
import java.util.ArrayList;
import java.util.List;
import org.mklab.nfc.matrix.ComplexNumericalMatrix;
import org.mklab.nfc.matrix.RealNumericalMatrix;
import org.mklab.nfc.nleq.NonLinearEquationSolver;
import org.mklab.nfc.ode.EquationSolver;
import org.mklab.nfc.ode.PiecewiseContinuousAlgebraicSystem;
import org.mklab.nfc.ode.PiecewiseUtil;
import org.mklab.nfc.ode.SolverStopException;
import org.mklab.nfc.scalar.ComplexNumericalScalar;
import org.mklab.nfc.scalar.RealNumericalScalar;
import org.mklab.tool.control.system.parameter.Parameter;
import org.mklab.tool.control.system.parameter.ParameterUpdator;
import org.mklab.tool.control.system.parameter.StringExternalizable;
/**
* 信号の値を制限するクラスです。 指定された値の範囲を超えるとシミュレーションを停止します。 計算を停止する例外を発生します。
*
* @author koga
* @version $Revision: 1.31 $, 2007/02/02
* @param <RS> type of real scalar
* @param <RM> type of real matrix
* @param <CS> type of complex scalar
* @param <CM> type of complex matrix
*/
public class Restrictor<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 ContinuousSink<RS,RM,CS,CM> implements PiecewiseContinuousAlgebraicSystem<RS,RM,CS,CM>, ParameterUpdator, StringExternalizable {
/** 許容範囲 */
@Parameter(name = "range", description = "Restrictor.1", update = true, internationalization = true)
private RM range;
/** 制限される信号のリスト(1番から始まる) */
private int[] restrictedSignals;
/**
* 新しく生成された<code>Restrictor</code>オブジェクトを初期化します。
* @param sunit unit of scalar
*/
public Restrictor(RS sunit) {
super(sunit);
RS[] rr = sunit.createArray(2);
rr[0] = sunit.getInfinity().unaryMinus();
rr[1] = sunit.getInfinity();
this.range = sunit.createGrid(rr);
}
// /**
// * 新しく生成された<code>Stopper</code>オブジェクトを初期化します。
// * @param size 信号の数
// */
// public Restrictor(final int size) {
// super(size);
// setupRange(Math.max(1, size));
// }
/**
* 許容範囲を設定します。
*
* @param size 信号の数
*/
private void setupRange(final int size) {
final RM rangeMatrix = this.sunit.createZeroGrid(size, 2);
for (int i = 1; i <= size; i++) {
rangeMatrix.setElement(i, 1, this.sunit.getInfinity().unaryMinus());
rangeMatrix.setElement(i, 2, this.sunit.getInfinity());
}
setRange(rangeMatrix);
}
/**
* 新しく生成された<code>Stopper</code>オブジェクトを初期化します。
*
* @param range 許容範囲 [[min1, max1][min2, max2]...[minN, maxN]]
* @param sunit unit of scalar
*/
public Restrictor(final RM range, RS sunit) {
super(range.getRowSize(), sunit);
setRange(range);
}
/**
* {@inheritDoc}
*/
@Override
public RM outputEquation( final RS t, final RM u) throws SolverStopException {
// 方程式のソルバーが仮の値で計算しているか判定します
final boolean solverTrial = EquationSolver.isTrial() || NonLinearEquationSolver.isTrial();
if (solverTrial == false) {
final RM realU = u;
for (int i = 1; i <= this.restrictedSignals.length; i++) {
final int number = this.restrictedSignals[i - 1];
if (this.range.getElement(i, 1).isLessThanOrEquals(realU.getElement(number)) && realU.getElement(number).isLessThanOrEquals(this.range.getElement(i, 2))) {
continue;
}
// 入力が許容範囲を越えるとシミュレーションを停止する
throw new SolverStopException(Messages.getString("Restrictor.0")); //$NON-NLS-1$
}
}
return this.sunit.createZeroGrid(getInputSize(), 1);
}
/**
* 許容範囲を設定します。
*
* @param range 許容範囲
*/
public void setRange(final RM range) {
final int size = range.getRowSize();
final int[] restrictedNumber = new int[size];
for (int i = 0; i < size; i++) {
restrictedNumber[i] = i + 1;
}
setRange(range, restrictedNumber);
}
/**
* 許容範囲を設定します。
*
* @param range 許容範囲
* @param restrictedSignal 制限される信号のリスト(1番から始まる)
*/
public void setRange(final RM range, final int[] restrictedSignal) {
this.range = range.createClone();
this.restrictedSignals = cloneIntArray(restrictedSignal);
final int size = range.getRowSize();
if (getInputSize() != size) {
super.setInputSize(size);
}
if (getOutputSize() != size) {
super.setOutputSize(size);
}
}
private int[] cloneIntArray(int[] array) {
final int[] clone = new int[array.length];
System.arraycopy(array, 0, clone, 0, array.length);
return clone;
}
/**
* 許容範囲を返します。
*
* @return 許容範囲
*/
public RM getRange() {
return this.range.createClone();
}
/**
* @see org.mklab.tool.control.system.parameter.ParameterUpdator#updateWith(java.lang.String)
*/
public boolean updateWith(final String parameter) {
if (parameter.equals("range")) { //$NON-NLS-1$
setRange(this.range);
return true;
}
return false;
}
/**
* @see org.mklab.tool.control.system.parameter.StringExternalizable#getString(java.lang.String)
*/
public String getString(String key) {
return Messages.getString(key);
}
/**
* @see org.mklab.tool.control.system.sink.ContinuousSink#setInputSize(int)
*/
@Override
public void setInputSize(final int inputSize) {
super.setInputSize(inputSize);
if (inputSize == -1) {
return;
}
if (this.range == null || this.range.getRowSize() != inputSize) {
setupRange(inputSize);
}
}
/**
* @see org.mklab.tool.control.system.sink.ContinuousSink#setOutputSize(int)
*/
@Override
public void setOutputSize(final int outputSize) {
super.setOutputSize(outputSize);
if (outputSize == -1) {
return;
}
if (this.range == null || this.range.getRowSize() != outputSize) {
setupRange(outputSize);
}
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("boxing")
public RS getDiscontinuousPoint(RS t1, RM u1, RS t2, RM u2) {
final List<Integer> pieces1 = getPiece(t1, u1);
final List<Integer> pieces2 = getPiece(t2, u2);
if (pieces1.equals(pieces2)) {
return this.sunit.getNaN();
}
final int number = PiecewiseUtil.getDistinctPiece(pieces1, pieces2);
final int piece1 = pieces1.get(number - 1);
final int piece2 = pieces2.get(number - 1);
final RS uu1 = u1.getElement(number);
final RS uu2 = u2.getElement(number);
final boolean fromOneToTwo = piece1 == 1 && piece2 == 2;
final boolean fromTwoToOne = piece1 == 2 && piece2 == 1;
final RS maximum = this.range.getElement(number, 2);
final RS minimum = this.range.getElement(number, 1);
if (fromOneToTwo || fromTwoToOne) {
return t1.add(maximum.subtract(uu1).divide(uu2.subtract(uu1)).multiply(t2.subtract(t1)));
}
final boolean fromOneToZero = piece1 == 1 && piece2 == 0;
final boolean fromZeroToOne = piece1 == 0 && piece2 == 1;
if (fromOneToZero || fromZeroToOne) {
return t1.add(uu1.subtract(minimum).divide(uu1.subtract(uu2)).multiply(t2.subtract(t1)));
}
assert false : "never reached"; //$NON-NLS-1$
return t1.add(t2).divide(2);
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("boxing")
public List<Integer> getPiece( RS t, RM u) {
final int size = u.getRowSize();
final List<Integer> pieces = new ArrayList<>(size);
for (int i = 1; i <= size; i++) {
final RS uu = u.getElement(i);
final RS minimum = this.range.getElement(i, 1);
final RS maximum = this.range.getElement(i, 2);
if (uu.isLessThan(minimum)) {
pieces.add(0);
} else {
if (uu.isLessThan(maximum)) {
pieces.add(1);
} else {
pieces.add(2);
}
}
}
return pieces;
}
/**
* @see org.mklab.tool.control.system.SystemOperator#equals(java.lang.Object)
*/
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!super.equals(o)) {
return false;
}
if (o == null) {
return false;
}
if (o.getClass() != getClass()) {
return false;
}
Restrictor<RS,RM,CS,CM> castedObj = (Restrictor<RS,RM,CS,CM>)o;
return ((this.range == null ? castedObj.range == null : this.range.equals(castedObj.range)) && java.util.Arrays.equals(this.restrictedSignals, castedObj.restrictedSignals));
}
/**
* @see org.mklab.tool.control.system.SystemOperator#hashCode()
*/
@Override
public int hashCode() {
int hashCode = super.hashCode();
hashCode = 31 * hashCode + (this.range == null ? 0 : this.range.hashCode());
for (int i0 = 0; this.restrictedSignals != null && i0 < this.restrictedSignals.length; i0++) {
hashCode = 31 * hashCode + this.restrictedSignals[i0];
}
return hashCode;
}
}