Заняття 1.

Дата добавления: 2015-10-19; просмотров: 423

package main;

import java.awt.Color;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import static java.lang.Math.exp;

import static java.lang.Math.sqrt;

import java.util.Random;

import org.jfree.chart.ChartFactory;

import org.jfree.chart.ChartFrame;

import org.jfree.chart.JFreeChart;

import org.jfree.chart.plot.PlotOrientation;

import org.jfree.chart.plot.XYPlot;

import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;

import org.jfree.data.xy.XYDataset;

import org.jfree.data.xy.XYSeries;

import org.jfree.data.xy.XYSeriesCollection;

public class Main {

private static void plotSP(double[] arr, double MX, double DX) {

XYSeries seriesSP = new XYSeries("СП", true, true);

XYSeries seriesMX = new XYSeries("MX", true, true);

XYSeries seriesSKO = new XYSeries("СКО", true, true);

XYSeries series_SKO = new XYSeries("-СКО", true, true);

for (int i = 0; i < 200; i++) {

seriesSP.add(i, arr[i]);

}

seriesMX.add(0, MX);

seriesMX.add(200, MX);

seriesSKO.add(0, MX + sqrt(DX));

seriesSKO.add(200, MX + sqrt(DX));

series_SKO.add(0, MX - sqrt(DX));

series_SKO.add(200, MX - sqrt(DX));

XYSeriesCollection collection = new XYSeriesCollection();

collection.addSeries(seriesSP);

collection.addSeries(seriesMX);

collection.addSeries(seriesSKO);

collection.addSeries(series_SKO);

XYDataset dataset = collection;

XYLineAndShapeRenderer r1 = new XYLineAndShapeRenderer();

r1.setSeriesPaint(0, Color.red);

r1.setSeriesPaint(1, Color.GREEN);

r1.setSeriesPaint(2, Color.BLUE);

r1.setSeriesPaint(3, Color.BLUE);

r1.setSeriesShapesVisible(0, false);

r1.setSeriesShapesVisible(1, false);

r1.setSeriesShapesVisible(2, false);

r1.setSeriesShapesVisible(3, false);

r1.setSeriesVisibleInLegend(3, false);

JFreeChart chart = ChartFactory.createXYLineChart("График СП", "Index", "Value", null);

XYPlot plot = (XYPlot) chart.getPlot();

plot.setDataset(0, dataset);

plot.setRenderer(0, r1);

plot.mapDatasetToRangeAxis(0, 0); //xz

plot.setBackgroundPaint(Color.LIGHT_GRAY);

plot.setDomainGridlinePaint(Color.WHITE);

plot.setRangeGridlinePaint(Color.WHITE);

ChartFrame frame = new ChartFrame("График", chart);

frame.pack();

frame.setVisible(true);

}

public static void plotR(double[] arr) {

XYSeries series = new XYSeries("r(m)", true, true);

XYSeries series_E = new XYSeries("+1/e,-1/e", true, true);

XYSeries seriesE = new XYSeries("1/e", true, true);

for (int i = 0; i < arr.length; i++) {

series.add(i, arr[i]);

}

series_E.add(0, -exp(-1));

series_E.add(15, -exp(-1));

seriesE.add(0, exp(-1));

seriesE.add(15, exp(-1));

XYSeriesCollection collection = new XYSeriesCollection();

collection.addSeries(series);

collection.addSeries(series_E);

collection.addSeries(seriesE);

JFreeChart chart = ChartFactory.createXYLineChart("Оценка НКФ исходного СП", "m", "r(m)", collection,

PlotOrientation.VERTICAL, true, true, false);

XYDataset dataset = collection;

XYLineAndShapeRenderer r1 = new XYLineAndShapeRenderer();

r1.setSeriesPaint(0, Color.red);

r1.setSeriesPaint(1, Color.BLUE);

r1.setSeriesPaint(2, Color.BLUE);

r1.setSeriesShapesVisible(0, false);

r1.setSeriesShapesVisible(1, false);

r1.setSeriesShapesVisible(2, false);

r1.setSeriesVisibleInLegend(2, false);

XYPlot plot = (XYPlot) chart.getPlot();

plot.setDataset(0, dataset);

plot.setRenderer(0, r1);

plot.mapDatasetToRangeAxis(0, 0); //xz

plot.setBackgroundPaint(Color.LIGHT_GRAY);

plot.setDomainGridlinePaint(Color.WHITE);

plot.setRangeGridlinePaint(Color.WHITE);

//Создание окна вывода

ChartFrame frame = new ChartFrame("НКФ", chart);

frame.pack();

frame.setVisible(true);

}

/**

* График для сравнения выборочной, теоретической и смоделированой НКФ.

*

* @param arr1 выборочная НКФ

* @param arr2 теоретическа НКФ

* @param arr3 смоделированная НКФ

* @param str Название модели (AR(2), MA(0), ARMA(2,3))

*/

public static void plotAll_R(double[] arr1, double[] arr2, double[] arr3, String str) {

XYSeries seriesArr1 = new XYSeries("исходная НКФ", true, true);

XYSeries seriesArr2 = new XYSeries("теоретическая НКФ", true, true);

XYSeries seriesArr3 = new XYSeries(str, true, true);

for (int i = 0; i < arr1.length; i++) {

seriesArr1.add(i, arr1[i]);

}

for (int i = 0; i < arr2.length; i++) {

seriesArr2.add(i, arr2[i]);

}

for (int i = 0; i < arr3.length; i++) {

seriesArr3.add(i, arr3[i]);

}

XYSeriesCollection collection = new XYSeriesCollection();

collection.addSeries(seriesArr1);

collection.addSeries(seriesArr2);

collection.addSeries(seriesArr3);

JFreeChart chart = ChartFactory.createXYLineChart("НКФ модели " + str, "m", "r(m)", collection,

PlotOrientation.VERTICAL, true, true, false);

XYDataset dataset = collection;

XYLineAndShapeRenderer r1 = new XYLineAndShapeRenderer();

r1.setSeriesPaint(0, Color.RED);

r1.setSeriesPaint(1, Color.BLUE);

r1.setSeriesPaint(2, Color.YELLOW);

r1.setSeriesShapesVisible(0, false);

r1.setSeriesShapesVisible(1, false);

r1.setSeriesShapesVisible(2, false);

XYPlot plot = (XYPlot) chart.getPlot();

plot.setDataset(0, dataset);

plot.setRenderer(0, r1);

plot.mapDatasetToRangeAxis(0, 0); //xz

plot.setBackgroundPaint(Color.LIGHT_GRAY);

plot.setDomainGridlinePaint(Color.WHITE);

plot.setRangeGridlinePaint(Color.WHITE);

//Создание окна вывода

ChartFrame frame = new ChartFrame("НКФ", chart);

frame.pack();

frame.setVisible(true);

}

/**

* Метод, подсчитывающий и выводящий на консоль первые 10 теоретических

* значений НКФ для данной модели АРСС(M,N) А также погрешность e^2 для

* данной модели

*

* @param M параметр М для модели ARMA(M,N)

* @param N параметр N для модели ARMA(M,N)

* @param rOld выборочная НКФ

* @param betas коэффициенты betas

*/

public static void eps2(int M, int N, double[] rOld, double[] betas) {

double[] rNew = new double[16];

double tmpSum = 0;

double eps2 = 0;

int m = 0;

while (m < N + M + 1) {

rNew[m] = rOld[m];

m++;

}

for (int i = m; i < 16; i++) {

for (int j = 0; j < M; j++) { //считаем значения НКФ

tmpSum += betas[j] * rNew[i - j];

}

rNew[i] = tmpSum;

}

System.out.println("ARRRRRRRRRRR");

for (int i = 1; i < 11; i++) {

System.out.println(rNew[i]);

}

System.out.println("");

for (int i = 1; i < 11; i++) {

eps2 += Math.pow(rNew[i] - rOld[i], 2);

}

System.out.println("Погрешность: " + eps2);

rNew = null;

}

public static double rand() {

Random randR = new Random(); //объекты будут создаваться при выхове статического метода?

double sum = -6;

for (int i = 0; i < 11; i++) {

sum += randR.nextDouble();//генерирует случайное число [0,1]

}

return sum;

}

/**

* Подсчет моментных функций:

*

* среднее по выборке макс мин диссперсия корреляционная функция нкф радиус

* корреляции

*

* + 2 графика СП НКФ

*

* @param array выборка

* @param str Заголовок: "Моментные функциии для +str"

*/

public static double[] momentsFunction(double[] array, String str) {

//среднее по выборке

double x_ = 0; //среднее

double current = 0;

double max = 0;

double min = 0;

double disp = 0;

double[] r = new double[16]; //КФ

double[] r_ = new double[16]; //НКФ

for (int i = 0; i < array.length; i++) {

current = array[i];

if (current > max) {

max = current;

} else if (current < min) {

min = current;

}

x_ += current;

}

x_ /= array.length;

x_ = Math.round(x_ * 10000);

x_ /= 10000;

System.out.println("Моментные функциии для " + str);

System.out.println("Среднее по выборке: " + x_);

System.out.println("Максимальное значение в выборке: " + max);

System.out.println("Минимальное значение в выборке: " + min);

//Выборочная не смещенная диссперсия

for (int i = 0; i < array.length; i++) {

disp += (array[i] - x_) * (array[i] - x_);

}

disp /= array.length;

disp = Math.round(disp * 10000);

disp /= 10000;

System.out.println("Выборочная диссперсия: " + disp);

//Корреляционная функция для k=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14.

System.out.println("Корреляционная функция:");

for (int k = 0; k < r.length; k++) {

for (int i = 0; i < array.length - k; i++) {

r[k] += (array[i] - x_) * (array[i + k] - x_);

}

r[k] /= (array.length - k);

r[k] = Math.round(r[k] * 10000);

r[k] /= 10000;

System.out.println(r[k]);

}

//НКФ

System.out.println("Нормированая корреляционная функция:");

int radius = 0;

for (int k = 0; k < r_.length; k++) {

r_[k] = r[k] / disp;

r_[k] = Math.round(r_[k] * 10000);

r_[k] /= 10000;

System.out.println(r_[k]);

if ((r_[k] >= (1 / Math.E)) || (r_[k] <= -(1 / Math.E))) {

radius = k;

}

}

System.out.println("Радиус корреляции: " + ++radius);

if ("исходной выборки".equals(str)) {

plotSP(array, x_, disp);

plotR(r_);

}

return r_;

}

public static double[] tehorNKF_MA0(double[] r_) {

// теоретические НКФ

double[] MA0 = new double[16];

double[] betas1 = {0};

double eps = 0;

MA0[0] = 1.000;

System.out.println("Теоретичесая НКФ MA(0):");

for (int i = 1; i < 16; i++) {

MA0[i] = 0;

}

for (int i = 1; i < 11; i++) {

System.out.println(0);

}

for (int i = 1; i < 11; i++) {//погрешности первых 10 погрешностей, начиная с индекса 1.

eps += Math.pow(MA0[i] - r_[i], 2);

}

System.out.println("Погрешность: " + eps);

System.out.println("");

return MA0;

}

public static double[] tehorNKF_AR2(double[] r_) {

// теоретические НКФ

double[] betas2 = {1.0425, -0.7726};

double[] AR2 = new double[16];

double eps = 0;

AR2[0] = 1.0000;

AR2[1] = 0.5881;

AR2[2] = -0.1595;

System.out.println("Теоретическая НКФ AR(2):");

for (int i = 3; i < 16; i++) {

AR2[i] = AR2[i - 1] * betas2[0] + AR2[i - 2] * betas2[1];

}

for (int i = 1; i < 11; i++) {//выписываем первые 10 значений

System.out.println(AR2[i]);

}

for (int i = 1; i < 11; i++) {//погрешности первых 10 погрешностей, начиная с индекса 1.

eps += Math.pow(AR2[i] - r_[i], 2);

}

System.out.println("Погрешность: " + eps);

System.out.println("");

return AR2;

}

public static double[] tehorNKF_ARMA23(double[] r_) {

// теоретические НКФ

double[] betas2 = {0.9444, -0.883};

double[] ARMA23 = new double[16];

double eps = 0;

ARMA23[0] = 1.0000;

ARMA23[1] = 0.5881;

ARMA23[2] = -0.1595;

System.out.println("Теоретичесая НКФ ARMA(2,3):");

for (int i = 3; i < 16; i++) {

ARMA23[i] = ARMA23[i - 1] * betas2[0] + ARMA23[i - 2] * betas2[1];

}

for (int i = 1; i < 11; i++) {

System.out.println(ARMA23[i]);

}

for (int i = 1; i < 11; i++) {//погрешности первых 10 погрешностей, начиная с индекса 1.

eps += Math.pow(ARMA23[i] - r_[i], 2);

}

System.out.println("Погрешность: " + eps);

System.out.println("");

return ARMA23;

}

public static double[] model_AR2() {

//Моделирование СП для модели АР(2)

double[] AR2 = new double[6000];

double[] riliAR2 = new double[5000];

AR2[0] = 49.947 + 10.5326 * rand();

AR2[1] = 49.947 + 1.0425 * AR2[0] + 10.5326 * rand();

AR2[2] = 49.947 + 1.0425 * AR2[1] - 0.7726 * AR2[0] + 10.5326 * rand();

for (int i = 3; i < 1000; i++) { //в холостую

AR2[i] = 49.947 + 1.0425 * AR2[i - 1] - 0.7726 * AR2[i - 2] + 10.5326 * rand();

}

for (int i = 1000; i < 6000; i++) {//рили

AR2[i] = 49.947 + 1.0425 * AR2[i - 1] - 0.7726 * AR2[i - 2] + 10.5326 * rand();

riliAR2[i - 1000] = AR2[i];

}

return riliAR2;

}

public static double[] model_MA0() {

double[] MA0 = new double[6000];

double[] riliMA0 = new double[5000];

//PrintWriter pwMA0 = new PrintWriter(new File("C:\\Users\\User\\Desktop\\MA0.txt"));

for (int i = 0; i < 1000; i++) { //в холостую

MA0[i] = 49.947 + 20.5136 * rand();

}

for (int i = 1000; i < 6000; i++) {//рили

MA0[i] = 49.947 + 20.5136 * rand();

riliMA0[i - 1000] = MA0[i];

}

return riliMA0;

}

public static double[] model_ARMA23() {

double[] ARMA23 = new double[6000];

double[] riliARMA23 = new double[5000];

double t0 = rand();

double t1 = rand();

double t2 = rand();

double t3 = rand();

ARMA23[0] = 49.947 - 4.8714 * t0;

ARMA23[1] = 49.947 + 0.9444 * ARMA23[0] - 4.8714 * t1 - 1.2166 * t0;

ARMA23[2] = 49.947 + 0.9444 * ARMA23[1] - 0.883 * ARMA23[0] - 4.8714 * t2 + 1.2166 * t1 - 12.5896 * t0;

ARMA23[3] = 49.947 + 0.9444 * ARMA23[2] - 0.883 * ARMA23[1] - 4.8714 * t3 + 1.2166 * t2 - 12.5896 * t1 - 2.7796 * t0;

for (int i = 4; i < 1000; i++) { //в холостую

t0 = t1;

t1 = t2;

t2 = t3;

t3 = rand();

ARMA23[i] = 49.947 + 0.9444 * ARMA23[i - 1] - 0.883 * ARMA23[i - 2] - 4.8714 * t3 + 1.2166 * t2 - 12.5896 * t1 - 2.7796 * t0;

}

for (int i = 1000; i < 6000; i++)

t0 = t1;

t1 = t2;

t2 = t3;

t3 = rand();

ARMA23[i] = 49.947 + 0.9444 * ARMA23[i - 1] - 0.883 * ARMA23[i - 2] - 4.8714 * t3 + 1.2166 * t2 - 12.5896 * t1 - 2.7796 * t0;

riliARMA23[i - 1000] = ARMA23[i];

}

return riliARMA23;

}

public static void main(String[] args) throws IOException {

BufferedReader in = new BufferedReader(new FileReader("C:\\Users\\User\\Desktop\\Учёба\\Математика\\ТСП\\Курсач\\input.txt"));

String tmp = null;

int c = 0;

double current = 0, eps = 0;

double[] array = new double[5000];//выборка

double[] r_ = new double[16]; //НКФ

while ((tmp = in.readLine()) != null) {

current = Double.parseDouble(tmp);

array[c++] = current;

}

System.out.println("********************************************");

r_ = momentsFunction(array, "исходной выборки");//выводим моментные функции для исходной выбрки

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

in.close();

//теоретические НКФ и их погрешности для лучших моделей AR(2),MA(0),ARMA(3)

double[] teorAR2 = new double[10];

double[] teorMA0 = new double[10];

double[] teorARMA23 = new double[10];

System.out.println("********************************************");

teorAR2 = tehorNKF_AR2(r_);

teorMA0 = tehorNKF_MA0(r_);

teorARMA23 = tehorNKF_ARMA23(r_);

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

//Моделирование моделей

double[] arrayAR2 = new double[5000];

double[] arrayMA0 = new double[5000];

double[] arrayARMA23 = new double[5000];

arrayAR2 = model_AR2();//смоделированные СП для лучших моделей

arrayMA0 = model_MA0();

arrayARMA23 = model_ARMA23();

//Анализ моделей

double[] r_AR2 = new double[16];

double[] r_MA0 = new double[16];

double[] r_ARMA23 = new double[16];

System.out.println("********************************************");

r_AR2 = momentsFunction(arrayAR2, "AR(2)");//выводим моментные функции для смоделированных моделей и сохраняем нкф каждой модели

for (int i = 1; i < 11; i++) {//погрешности первых 10 погрешностей, начиная с индекса 1.

eps += Math.pow(r_AR2[i] - r_[i], 2);

}

System.out.println("Погрешность: " + eps);

eps = 0;

System.out.println();

r_MA0 = momentsFunction(arrayMA0, "MA(0)");

for (int i = 1; i < 11; i++) {//погрешности первых 10 погрешностей, начиная с индекса 1.

eps += Math.pow(r_MA0[i] - r_[i], 2);

}

System.out.println("Погрешность: " + eps);

eps = 0;

System.out.println();

r_ARMA23 = momentsFunction(arrayARMA23, "ARMA(2,3)");

for (int i = 1; i < 11; i++) {//погрешности первых 10 погрешностей, начиная с индекса 1.

eps += Math.pow(r_ARMA23[i] - r_[i], 2);

}

System.out.println("Погрешность: " + eps);

eps = 0;

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

//Графики НКФ для лучших моделей

plotAll_R(r_, teorAR2, r_AR2, "AR(2)");

plotAll_R(r_, teorMA0, r_MA0, "MA(0)");

plotAll_R(r_, teorARMA23, r_ARMA23, "ARMA(2,3)");

//График выборки смоделированной СП

plotSP(arrayARMA23, 63.4437, 732.1111);

}

}