Author: jcouteau Date: 2009-03-25 12:15:23 +0000 (Wed, 25 Mar 2009) New Revision: 2036 Modified: isis-fish/trunk/src/main/java/fr/ifremer/isisfish/simulator/sensitivity/domain/EquationContinuousDomain.java isis-fish/trunk/src/test/java/fr/ifremer/isisfish/simulator/SimulationPreScriptTest.java isis-fish/trunk/src/test/java/fr/ifremer/isisfish/simulator/sensitivity/FactorTest.java Log: Fully functional EquationContinuousDomain with unit tests. Adaptation of SimulationPreScriptTest to this new Domain. Modified: isis-fish/trunk/src/main/java/fr/ifremer/isisfish/simulator/sensitivity/domain/EquationContinuousDomain.java =================================================================== --- isis-fish/trunk/src/main/java/fr/ifremer/isisfish/simulator/sensitivity/domain/EquationContinuousDomain.java 2009-03-25 11:33:30 UTC (rev 2035) +++ isis-fish/trunk/src/main/java/fr/ifremer/isisfish/simulator/sensitivity/domain/EquationContinuousDomain.java 2009-03-25 12:15:23 UTC (rev 2036) @@ -20,28 +20,31 @@ import java.io.Serializable; +import org.codelutin.math.matrix.MapFunction; + /** - * Domaine continu portant sur variable pouvant prendre diférente - * valeur par rapport à une valeur initiale. + * Domaine continu portant sur variable pouvant prendre diférente valeur par + * rapport à une valeur initiale. * * Composé d'un borne min et max et d'un opération. - * - * @param <E> type des valeurs gérées par le domaine * + * @param <E> + * type des valeurs gérées par le domaine + * * @author chatellier * @version $Revision: 1.0 $ * - * Last update : $Date: 24 févr. 2009 $ - * By : $Author: chatellier $ + * Last update : $Date: 24 févr. 2009 $ By : $Author: chatellier $ */ -public class EquationContinuousDomain<E extends Serializable> extends ContinuousDomain<E> { +public class EquationContinuousDomain<E extends Serializable> extends + ContinuousDomain<E> { /** serialVersionUID. */ private static final long serialVersionUID = -2037768174807839046L; /** Variable name (must be java valid identifier) */ protected String variableName; - + /** Operation. (=,+,-,/) */ protected String operator; @@ -70,7 +73,8 @@ /** * Set variable name. * - * @param variableName the variableName to set + * @param variableName + * the variableName to set */ public void setVariableName(String variableName) { this.variableName = variableName; @@ -88,7 +92,8 @@ /** * Set operator. * - * @param operator the operator to set + * @param operator + * the operator to set */ public void setOperator(String operator) { this.operator = operator; @@ -96,7 +101,7 @@ /** * Get coefficient. - * + * * @return the coefficient */ public Double getCoefficient() { @@ -105,8 +110,9 @@ /** * Set coefficient. - * - * @param the coefficient to set + * + * @param the + * coefficient to set */ public void setCoefficient(Double coefficient) { this.coefficient = coefficient; @@ -114,7 +120,7 @@ /** * Get reference value. - * + * * @return the reference value */ public Double getReferenceValue() { @@ -123,8 +129,9 @@ /** * Set reference value. - * - * @param the reference value.to set + * + * @param the + * reference value.to set */ public void setReferenceValue(Double referenceValue) { this.referenceValue = referenceValue; @@ -133,11 +140,43 @@ /** * {@inheritDoc}. * - * In equation continuous domain, value appear in - * continuous domain values only. - * Here : return identifier. + * In equation continuous domain, always return 0 */ + @Override + public double getMinBound() { + return 0; + } + + /** + * {@inheritDoc}. + * + * In equation continuous domain, always return 1 + */ + @Override + public double getMaxBound() { + return 1; + } + + /** + * {@inheritDoc}. + * + * In equation continuous domain, value appear in continuous domain values + * only. Here : return identifier. + */ public E getValueForIdentifier(Serializable identifier) { - return (E)identifier; + if (operator.equals("+")) { + return (E) ((Double) (referenceValue + ((referenceValue + coefficient) * ((2 * Double + .valueOf((String) identifier)) - 1)))); + } else if (operator.equals("-")) { + return (E) ((Double) (referenceValue + ((referenceValue - coefficient) * ((2 * Double + .valueOf((String) identifier)) - 1)))); + } else if (operator.equals("*")) { + return (E) ((Double) (referenceValue + ((referenceValue * coefficient) * ((2 * Double + .valueOf((String) identifier)) - 1)))); + } else if (operator.equals("/")) { + return (E) ((Double) (referenceValue + ((referenceValue / coefficient) * ((2 * Double + .valueOf((String) identifier)) - 1)))); + } + return (E) identifier; } } Modified: isis-fish/trunk/src/test/java/fr/ifremer/isisfish/simulator/SimulationPreScriptTest.java =================================================================== --- isis-fish/trunk/src/test/java/fr/ifremer/isisfish/simulator/SimulationPreScriptTest.java 2009-03-25 11:33:30 UTC (rev 2035) +++ isis-fish/trunk/src/test/java/fr/ifremer/isisfish/simulator/SimulationPreScriptTest.java 2009-03-25 12:15:23 UTC (rev 2036) @@ -292,13 +292,13 @@ // factor Factor<Double> factorEquation = new Factor<Double>("test equation"); EquationContinuousDomain<Double> domain1 = new EquationContinuousDomain<Double>(); - domain1.setMinBound(0.0); - domain1.setMaxBound(3.0); + domain1.setReferenceValue(3.0); domain1.setOperator("-"); + domain1.setCoefficient(0.1); domain1.setVariableName("PopulationEquation.K1"); factorEquation.setDomain(domain1); factorEquation.setPath("org.codelutin.equation1#testFactorPreScriptEquation"); - factorEquation.setValueForIdentifier(2.0); + factorEquation.setValueForIdentifier("0.1"); log.info("Script = " + domain1.getClass().getSimpleName()); @@ -320,6 +320,6 @@ out.flush(); String scriptContent = out.toString(); //log.info("Script = " + scriptContent); - Assert.assertTrue(scriptContent.indexOf("\"PopulationEquation.K1\", 2, \"-\"") != -1); + Assert.assertTrue(scriptContent.indexOf("\"PopulationEquation.K1\", 0,68, \"-\"") != -1); } } Modified: isis-fish/trunk/src/test/java/fr/ifremer/isisfish/simulator/sensitivity/FactorTest.java =================================================================== --- isis-fish/trunk/src/test/java/fr/ifremer/isisfish/simulator/sensitivity/FactorTest.java 2009-03-25 11:33:30 UTC (rev 2035) +++ isis-fish/trunk/src/test/java/fr/ifremer/isisfish/simulator/sensitivity/FactorTest.java 2009-03-25 12:15:23 UTC (rev 2036) @@ -25,8 +25,10 @@ import org.junit.Assert; import org.junit.Test; +import fr.ifremer.isisfish.entities.Equation; import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain; import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain; +import fr.ifremer.isisfish.simulator.sensitivity.domain.EquationContinuousDomain; import fr.ifremer.isisfish.simulator.sensitivity.domain.MatrixContinuousDomain; /** @@ -246,4 +248,92 @@ log.info("factor#toString() = " + factor); } } + + /** + * Test factor with matrix. + * + * @see MatrixND + */ + @Test + public void testEquationContinuousFactor() { + + // factor + Factor<Double> factor = new Factor<Double>("testequation"); + EquationContinuousDomain<Double> domain = new EquationContinuousDomain<Double>(); + domain.setCoefficient(0.1); + domain.setOperator("*"); + domain.setVariableName("Linf"); + domain.setReferenceValue(3.0); + factor.setDomain(domain); + factor + .setPath("org.codelutin.math.matrix.MatrixND#563456293453#2.456347646#dim"); + factor.setValueForIdentifier("0.1"); + + Assert.assertEquals(2.76, factor.getValue(),0.0000001); + Assert.assertEquals(0,((ContinuousDomain)factor.getDomain()).getMinBound(),0); + Assert.assertEquals(1,((ContinuousDomain)factor.getDomain()).getMaxBound(),0); + + + + // factor 2 + Factor<Double> factor2 = new Factor<Double>("testequation"); + EquationContinuousDomain<Double> domain2 = new EquationContinuousDomain<Double>(); + domain2.setCoefficient(0.1); + domain2.setOperator("/"); + domain2.setVariableName("Linf"); + domain2.setReferenceValue(3.0); + factor2.setDomain(domain2); + factor2 + .setPath("org.codelutin.math.matrix.MatrixND#563456293453#2.456347646#dim"); + factor2.setValueForIdentifier("0.1"); + + Assert.assertEquals(-21, Double.valueOf(factor2.getValue()),0.0000001); + Assert.assertEquals(0,((ContinuousDomain)factor.getDomain()).getMinBound(),0); + Assert.assertEquals(1,((ContinuousDomain)factor.getDomain()).getMaxBound(),0); + + // factor 3 + Factor<Double> factor3 = new Factor<Double>("testequation"); + EquationContinuousDomain<Double> domain3 = new EquationContinuousDomain<Double>(); + domain3.setCoefficient(0.1); + domain3.setOperator("+"); + domain3.setVariableName("Linf"); + domain3.setReferenceValue(3.0); + factor3.setDomain(domain3); + factor3 + .setPath("org.codelutin.math.matrix.MatrixND#563456293453#2.456347646#dim"); + factor3.setValueForIdentifier("0.1"); + + Assert.assertEquals(0.52, Double.valueOf(factor3.getValue()),0.0000001); + Assert.assertEquals(0,((ContinuousDomain)factor.getDomain()).getMinBound(),0); + Assert.assertEquals(1,((ContinuousDomain)factor.getDomain()).getMaxBound(),0); + + // factor 4 + Factor<Double> factor4 = new Factor<Double>("testequation"); + EquationContinuousDomain<Double> domain4 = new EquationContinuousDomain<Double>(); + domain4.setCoefficient(0.1); + domain4.setOperator("-"); + domain4.setVariableName("Linf"); + domain4.setReferenceValue(3.0); + factor4.setDomain(domain4); + factor4 + .setPath("org.codelutin.math.matrix.MatrixND#563456293453#2.456347646#dim"); + factor4.setValueForIdentifier("0.1"); + + Assert.assertEquals(0.68, Double.valueOf(factor4.getValue()),0.0000001); + Assert.assertEquals(0,((ContinuousDomain)factor.getDomain()).getMinBound(),0); + Assert.assertEquals(1,((ContinuousDomain)factor.getDomain()).getMaxBound(),0); + + try { + factor.setValueForIdentifier("blah blah"); + Assert.fail("Can't set identifier not present in domain"); + } catch (IllegalArgumentException e) { + if (log.isInfoEnabled()) { + log.info("Exception normally thrown"); + } + } + + if (log.isInfoEnabled()) { + log.info("factor#toString() = " + factor); + } + } }