Построение имитационной модели функционирования системы

return true;

return b7;

}

static void printBlockData(int n)

{

System.out.println("Data for n = " + n);

System.out.println("-------------------\n");

for(int i = 0; i < 7; i++)

// System.out.println("t" + (i + 1) + " = " + df.format(tArray[i]));

System.out.println

("t" + (i + 1) + " = " + tArray[i]);

System.out.println();

}

/**

* @return <code>true</code> если <b>text</b> число и меньше или равно maxVal

*/

static boolean isNumder(String text, int maxVal)

{

double t = 0;

try

{

t = Double.parseDouble(text);

}

catch(NumberFormatException e)

{

return false;

}

return t <= maxVal && t > 0;

}

}

import java.util.Random;

import org.apache.commons.math.MathException;

import org.apache.commons.math.distribution.ExponentialDistributionImpl;

import org.apache.commons.math.distribution.NormalDistributionImpl;

import org.apache.commons.math.random.RandomDataImpl;

public abstract class distribution

{

static Random random = new Random(System.currentTimeMillis());

static double SQRT2PI = Math.sqrt(2 * Math.PI);

static boolean AltFormuls = false;

static enum DISTRIBUTIONS

{

UNIFORM, EXPONENTIAL, NORMAL, SYMMETRIC_TRAGNGLE

}

/**

* Генерируем данные для блока

*/

static double Distribution(double arg1, double arg2, DISTRIBUTIONS uniform)

{

switch (uniform)

{

case UNIFORM:

return !AltFormuls ? uniformDistribution(arg1, arg2) : new RandomDataImpl().nextUniform(arg1, arg2);

case EXPONENTIAL:

return !AltFormuls ? exponentialDistribution(arg1 / arg2) : new RandomDataImpl().nextExponential(arg1 / arg2);

case NORMAL:

return !AltFormuls ? normalDistribution(arg1, arg2) : new RandomDataImpl().nextGaussian(arg1, arg2);

case SYMMETRIC_TRAGNGLE:

return !AltFormuls ? symmetricTragngleDistribution(arg1, arg2) : new RandomDataImpl().nextUniform(arg1 / 2, arg2 / 2) + new RandomDataImpl().nextUniform(arg1 / 2, arg2 / 2);

default:

System.out.println("distribution: error - wrong type.");

}

return 0;

}

/**

* Метод для равномерного распределении случайной величины на интервале [a;b]

*/

public static double uniformDistribution(double a, double b)

{

double x = altUniformDistribution(a, b);

if(x <= a)

return 0.0D;

if(x >= b)

return 1.0D;

return (x - a) / (b - a);

}

/**

* Альтернативный метод для равномерного распределении случайной величины на интервале [a;b]

*/

public static double altUniformDistribution(double a, double b)

{

return a + rnd((int) Math.floor((b - a)));

}

/**

* Метод для экспоненциального распределения случайной величины

*

* @param gamma

* - параметр распределения

*/

public static double exponentialDistribution(double gamma)

{

ExponentialDistributionImpl ed = new ExponentialDistributionImpl(gamma);

try

{

return ed.cumulativeProbability(rnd());

}

catch(MathException e)

{

e.printStackTrace();

}

return 0;

}

/**

* Альтернативный метод для экспоненциального распределения случайной величины

*

* @param gamma

* - параметр распределения

*/

public static double altExponentialDistribution(double gamma)

{

return 1.0D - Math.exp(-rnd() * gamma);

}

/**

* Метод для нормального (Gauss) распределения случайной величины

*

* @param sigma

* - коэффициент масштаба

* @param m

* - коэффициент сдвига

*/

public static double normalDistribution(double sigma, double m)

{

NormalDistributionImpl ed = new NormalDistributionImpl(sigma, m);

try

{

return ed.cumulativeProbability(rnd());

}

catch(MathException e)

{

e.printStackTrace();

}

return 0;

}

/**

* Альтернативный vетод для нормального (Gauss) распределения случайной величины

*

* @param sigma

* - коэффициент масштаба

* @param m

* - коэффициент сдвига

*/

public static double altNormalDistribution(double sigma, double m)

{

double t1 = 1.0D / (sigma * SQRT2PI);

double t2 = Sqr(rnd() - m) / (2.0D * Sqr(sigma));

return Math.exp(-t2) * t1;

}

/**

* Метод для симметричного треугольное распределения заданного на отрезке [c;d]

*/

public static double symmetricTragngleDistribution(double c, double d)

{

double a = c / 2.0D;

double b = d / 2.0D;

return uniformDistribution(a, b) + uniformDistribution(a, b);

}

/**

* Возведение x в степень 2

*/

static double Sqr(double x)

{

return Math.pow(x, 2);

}

/**

* Возвращает случайное число от 0 до 1 (не включая единицу)

*/

static double rnd()

{

double u;

while (true)

{

u = random.nextDouble();

// нельзя, чтобы u получилось равное 0, т.к. логарифм от нуля не существует

if(u > 0.001)

break;

}

return u;

}

/**

* Возвращает случайное число от 0 до n

*/

static int rnd(int n)

{

int u;

while (true)

{

u = random.nextInt(n);

// нельзя, чтобы u получилось равное 0, т.к. логарифм от нуля не существует

if(u > 0)

break;

}

return u;

}

}

Размещено на Allbest.ru

 Скачать реферат