import java.util.

*;
import java.util.Arrays;
import java.util.Random;
import java.lang.Math;

public abstract class GeneralLaw

extends Utilities
implements Serializable, EnvironmentConstants, AgentConstants{

/**
* Default constructor
*/

public GeneralLaw() {
}

/** public static double triangular(double a, double b, double c) {

double F = (c - a) / (b - a);
double rand = Math.random();
if (rand < F) {
return a + Math.sqrt(rand * (b - a) * (c - a));
} else {
return b - Math.sqrt((1 - rand) * (b - a) * (b - c));
}
}
**/

public static double[] law(String lawArguments) {

String [] args= lawArguments.split(",");
double[] nums = new double[args.length];
for (int i = 0; i < nums.length; i++) {
nums[i] = Double.parseDouble(args[i]);
}
return nums;
}

public double law(int dindex, double [] doubles)

{
switch( dindex ) {
case 0: return uniform();
case 1: return uniform_pos();
case 2: return uniform( doubles[0] );
case 3: return uniform( doubles[0], doubles[1] );
case 4: return randomTrue( doubles[0] ) ? 1 : 0;
case 5: return randomFalse( doubles[0] ) ? 1 : 0;
case 6: return bernoulli( doubles[0] );
case 7: return beta( doubles[0], doubles[1] );
case 8: return beta( doubles[0], doubles[1], doubles[2], doubles[3] );
case 9: return beta( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4], doubles[5] );
case 10: return binomial( doubles[0] );
 case 11: return binomial( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4], doubles[5] );
case 12: return cauchy( doubles[0] );
case 13: return cauchy( doubles[0], doubles[1] );
case 14: return chi2( doubles[0] );
case 15: return chi2( doubles[0], doubles[1] );
case 16: return exponential();
case 17: return exponential( doubles[0] );
case 18: return exponential( doubles[0], doubles[1] );
case 19: return exponential( doubles[0], doubles[1], doubles[2],
doubles[3] );
case 20: return gamma( doubles[0], doubles[1] );
case 21: return gamma( doubles[0], doubles[1], doubles[2] );
case 22: return gamma( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4] );
case 23: return geometric( doubles[0] );
case 24: return gumbel1( doubles[0], doubles[1] );
case 25: return gumbel2( doubles[0], doubles[1] );
case 26: return laplace( doubles[0], doubles[1] );
case 27: return logarithmic( doubles[0] );
case 28: return logistic( doubles[0], doubles[1] );
case 29: return lognormal( doubles[0], doubles[1], doubles[2] );
case 30: return negativeBinomial( doubles[0], doubles[1] );
case 31: return negativeBinomial( doubles[0], doubles[1], doubles[2],
doubles[3], doubles[4], doubles[5] );
case 32: return normal();
case 33: return normal( doubles[0] );
case 34: return normal( doubles[0], doubles[1] );
case 35: return normal( doubles[0], doubles[1], doubles[2], doubles[3] );
case 36: return pareto( doubles[0] );
case 37: return pareto( doubles[0], doubles[1] );
case 38: return poisson( doubles[0] );
case 39: return poisson( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4] );
case 40: return rayleigh( doubles[0] );
case 41: return rayleigh( doubles[0], doubles[1] );
case 42: return triangular( doubles[0], doubles[1] );
case 43: return triangular( doubles[0], doubles[1], doubles[2] );
case 44: return triangular( doubles[0], doubles[1], doubles[2],
doubles[3], doubles[4] );
case 45: return pert( doubles[0], doubles[1], doubles[2] );
case 46: return weibull( doubles[0], doubles[1] );
case 47: return weibull( doubles[0], doubles[1], doubles[2] );
case 48: return weibull( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4] );
default: error( "Invalid distribution index: " + dindex ); return 0;
}
}

/**
public static double[] law1(int lawType,double [] nums) {
//String [] args= lawArguments.split(",");
//double[] nums = new double[args.length];
//for (int i = 0; i < nums.length; i++) {
 // nums[i] = Double.parseDouble(args[i]);
//}

Random rand = new Random();

double res;
if (lawType==1) {
res= triangular(nums[0],nums[1],nums[2]);
}
else if (lawType==2) {
res= exponential(nums[0],nums[1],rand);
}
else if (lawType==3) {
res= "gamma"+lawArguments;
}
else if (lawType==4) {
res= "pareto"+lawArguments;
}
else if (lawType==5) {
res= "lognorm"+lawArguments;
}
else if (lawType==6) {
res= "invgamma"+lawArguments;
}
else if (lawType==7) {
res= "invgauss"+lawArguments;
}
else if (lawType==8) {
res= "loggamma"+lawArguments;
}
else if (lawType==9) {
res= "alpha"+lawArguments;
}
else if (lawType==10) {
res= "chi"+lawArguments;
}
else if (lawType==11) {
res= "chi2"+lawArguments;
}
else if (lawType==12) {
res= "t"+lawArguments;
}
return 0;
}
**/

@Override
public String toString() {
return super.toString();
}

/**
* This number is here for model snapshot storing purpose<br>
* It needs to be changed when this class gets changed
*/
private static final long serialVersionUID = 1L;
}

La méthode loi

public double law(int dindex, double [] doubles) {

Random r = new Random();
System.out.println("nb arguments : "+((doubles != null)?doubles.length:0));
switch( dindex ) {
case 0: return uniform( doubles [0], doubles [1],r);
case 1: return uniform_pos(r);
case 2: return bernoulli( doubles[0], r);
case 3: return beta( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4], doubles[5],r );
case 4: return binomial( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4], doubles[5], r );
case 5: return cauchy( doubles[0], doubles[1], r);
case 6: return chi2( doubles[0], doubles[1], r);
case 7: return exponential( doubles[0], doubles[1], r );
case 8: return exponential( doubles[0], doubles[1], doubles[2],
doubles[3], r);
case 9: return gamma_frac( doubles[0], r );
case 10: return gamma( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4], r );
case 11: return geometric( doubles[0], r );
case 12: return gumbel1( doubles[0], doubles[1], r);
case 13: return gumbel2( doubles[0], doubles[1],r);
case 14: return laplace( doubles[0], doubles[1], r );
case 15: return logarithmic( doubles[0],r );
case 16: return logistic( doubles[0], doubles[1],r );
case 17: return lognormal( doubles[0], doubles[1], doubles[2],r );
case 18: return negativeBinomial( doubles[0], doubles[1], r );
case 19: return negativeBinomial( doubles[0], doubles[1], doubles[2],
doubles[3], doubles[4], doubles[5], r );
case 20: return normal( doubles[0], doubles[1], r );
case 21: return normal( doubles[0], doubles[1], doubles[2], doubles[3],
r );
case 22: return pareto( doubles[0], doubles[1], r );
case 23: return poisson( doubles[0], r );
case 24: return poisson( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4],r );
case 25: return rayleigh( doubles[0], doubles[1], r);
case 26: return triangularAV( doubles[0], doubles[1], r );
case 27: return triangular( doubles[0], doubles[1], doubles[2],
doubles[3], doubles[4], r);
case 28: return pert( doubles[0], doubles[1], doubles[2], r );
 case 29: return weibull( doubles[0], doubles[1], doubles[2], r);
case 30: return weibull( doubles[0], doubles[1], doubles[2], doubles[3],
doubles[4], r );
default: return -1;
}