testanalytical.java

一个用于排队系统仿真的开源软件,有非常形象的图象仿真过程!

/**    
  * Copyright (C) 2006, Laboratorio di Valutazione delle Prestazioni - Politecnico di Milano

  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.

  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.

  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
  
package jmt.test.analytical;

import jmt.analytical.*;

import java.util.Random;

/**
 * @author Stefano
 * @version 7-giu-2004 10.01.14
 */
public class TestAnalytical {

    /**
     * Test
     */
    public static void testMultiOpenLI() {

        System.out.println("Sistema aperto con 2 classi");
        long start = System.currentTimeMillis();


         double[] lambda = new double[2];
        lambda[0] = 0.05;
        lambda[1] = 0.05;

		SolverMultiOpen mOpen = new SolverMultiOpen(2, 3, lambda);

        String[] name = {"Delay", "Disk1", "CPU"};
		int[] type = {Solver.DELAY, Solver.LI, Solver.LI, };
		double[][][] servt = new double[3][2][1];

		//station 1
        servt[0][0][0] = 5;
        servt[0][1][0] = 5;

        //station 2
        servt[1][0][0] = 0.005;
        servt[1][1][0] = 0.002;

        //station 3
        servt[2][0][0] = 0.015;
        servt[2][1][0] = 0.012;


        double[][] visits = new double[3][2];

        //station 1
        visits[0][0] = 1;
        visits[0][1] = 1;

        //station 2
        visits[1][0] = 70;
        visits[1][1] = 120;

        //station 3
        visits[2][0] = 35;
        visits[2][1] = 20;

		if (mOpen.input(name, type, servt, visits)){
            if(mOpen.hasSufficientProcessingCapacity()){
                mOpen.solve();
                System.out.println(mOpen);
                System.out.println("End Multi LI");
                long stop = System.currentTimeMillis();
                System.out.print("Tempo trascorso: " + (stop - start));
                System.out.println();
            } else {
                System.out.println("No sufficient processing capacity!");
            }
        } else {
            System.out.println("Wrong input!!");
        }





	}





    /**
     * Test
     */
    public static void testMultiOpenLI2() {

        System.out.println("Sistema aperto con 3 classi");
        long start = System.currentTimeMillis();


         double[] lambda = new double[3];
        lambda[0] = 0.05;
        lambda[1] = 0.05;
        lambda[2] = 0.05;

		SolverMultiOpen mOpen = new SolverMultiOpen(3, 2, lambda);

        String[] name = {"Disk1", "CPU"};
		int[] type = {Solver.LI, Solver.LI, };
		double[][][] servt = new double[2][3][1];

		//station 1
        servt[0][0][0] = 0.005;
        servt[0][1][0] = 0.005;
        servt[0][2][0] = 0.005;

        //station 2
        servt[1][0][0] = 0.005;
        servt[1][1][0] = 0.002;
        servt[1][2][0] = 0.002;




        double[][] visits = new double[2][3];

        //station 1
        visits[0][0] = 1;
        visits[0][1] = 1;
        visits[0][2] = 1;

        //station 2
        visits[1][0] = 70;
        visits[1][1] = 120;
        visits[1][2] = 120;


		if (mOpen.input(name, type, servt, visits)){
            if(mOpen.hasSufficientProcessingCapacity()){
                mOpen.solve();
                System.out.println(mOpen);
                System.out.println("End Multi LI");
                long stop = System.currentTimeMillis();
                System.out.print("Tempo trascorso: " + (stop - start));
                System.out.println();
            } else {
                System.out.println("No sufficient processing capacity!");
            }
        } else {
            System.out.println("Wrong input!!");
        }





	}




    public static void testMultiClosedLI() {

        System.out.println("Sistema chiuso con 2 classi");
        long start = System.currentTimeMillis();

        SolverMultiClosedMVA mClosed = new SolverMultiClosedMVA(3, 2);

        String[] name = {"Station1", "Station2"};
		int[] type = {Solver.LI, Solver.LI, };
		double[][][] servt = new double[2][3][1];

        int[] pop = new int[3];
        pop[0] = 10;
        pop[1] = 10;
        pop[2] = 10;

		//station 1
        servt[0][0][0] = 10;
        servt[0][1][0] = 5;
        servt[0][2][0] = 1;

        //station 2
        servt[1][0][0] = 5;
        servt[1][1][0] = 9;
        servt[1][2][0] = 1;

        double[][] visits = new double[2][3];

        //station 1
        visits[0][0] = 1;
        visits[0][1] = 1;
        visits[0][2] = 1;

        //station 2
        visits[1][0] = 1;
        visits[1][1] = 1;
        visits[1][2] = 1;

		if (mClosed.input(name, type, servt, visits, pop)){
            mClosed.solve();
            System.out.println(mClosed);
            System.out.println("End Multi Closed LI");
            long stop = System.currentTimeMillis();
            System.out.print("Tempo trascorso: " + (stop - start));
            System.out.println();

        } else {
            System.out.println("Wrong input!!");
        }





	}



    public static void testMultiClosedLI_visits_not1() {

        System.out.println("Sistema chiuso con 2 classi");
        long start = System.currentTimeMillis();

        SolverMultiClosedMVA mClosed = new SolverMultiClosedMVA(2, 2);

        String[] name = {"Station1", "Station2"};
		int[] type = {Solver.LI, Solver.LI, };
		double[][][] servt = new double[2][2][1];

        int[] pop = new int[2];
        pop[0] = 100;
        pop[1] = 50;

		//station 1
        servt[0][0][0] = 10;
        servt[0][1][0] = 5;

        //station 2
        servt[1][0][0] = 5;
        servt[1][1][0] = 9;

        double[][] visits = new double[2][2];

        //station 1
        visits[0][0] = 3;
        visits[0][1] = 4;

        //station 2
        visits[1][0] = 2;
        visits[1][1] = 5;


		if (mClosed.input(name, type, servt, visits, pop)){
            mClosed.solve();
            System.out.println(mClosed);
            System.out.println("End Multi Closed LI");
            long stop = System.currentTimeMillis();
            System.out.print("Tempo trascorso: " + (stop - start));
            System.out.println();

        } else {
            System.out.println("Wrong input!!");
        }





	}


    public static void testMultiClosedLI_big() {

        System.out.println("Sistema chiuso con 4 classi");
        long start = System.currentTimeMillis();

        SolverMultiClosedMVA mClosed = new SolverMultiClosedMVA(4, 2);

        String[] name = {"Station1", "Station2"};
		int[] type = {Solver.LI, Solver.LI, };
		double[][][] servt = new double[2][4][1];

        int[] pop = new int[4];
        pop[0] = 100;
        pop[1] = 100;
        pop[2] = 100;
        pop[3] = 100;

		//station 1
        servt[0][0][0] = 10;
        servt[0][1][0] = 5;
        servt[0][2][0] = 10;
        servt[0][3][0] = 5;

        //station 2
        servt[1][0][0] = 5;
        servt[1][1][0] = 9;
        servt[1][2][0] = 4;
        servt[1][3][0] = 5;

        double[][] visits = new double[2][4];

        //station 1
        visits[0][0] = 1;
        visits[0][1] = 1;
        visits[0][2] = 1;
        visits[0][3] = 1;

        //station 2
        visits[1][0] = 1;
        visits[1][1] = 1;
        visits[1][2] = 1;
        visits[1][3] = 1;


		if (mClosed.input(name, type, servt, visits, pop)){
            mClosed.solve();
            System.out.println(mClosed);
            System.out.println("End Multi Closed LI");
            long stop = System.currentTimeMillis();
            System.out.print("Tempo trascorso: " + (stop - start));
            System.out.println();

        } else {
            System.out.println("Wrong input!!");
        }





	}




    /**
     * Test
     */
    public static void testMultiMixed() {

        System.out.println("Sistema misto con 2 classi");
        long start = System.currentTimeMillis();

        int[] classTypes = new int[2];
        classTypes[0] = SolverMulti.OPEN_CLASS;
        classTypes[1] = SolverMulti.CLOSED_CLASS;

        double[] classData = new double[2];
        classData[0] = 0.005;
        classData[1] = 10;

		SolverMultiMixed multiMixed = new SolverMultiMixed(2, 2);

        String[] name = {"Station1", "Station2"};
		int[] type = {Solver.LI, Solver.LI};
		double[][][] servt = new double[2][2][1];

		//station 1
        servt[0][0][0] = 0.002;
        servt[0][1][0] = 0.005;

        //station 2
        servt[1][0][0] = 0.003;
        servt[1][1][0] = 0.004;


        double[][] visits = new double[2][2];

        //station 1
        visits[0][0] = 5;
        visits[0][1] = 5;

        //station 2
        visits[1][0] = 1;
        visits[1][1] = 3;


		if (multiMixed.input(name, type, servt, visits, classData, classTypes)){

            multiMixed.solve();
            System.out.println(multiMixed);
            System.out.println("End Multi mixed");
            long stop = System.currentTimeMillis();
            long elapsed = stop - start;
            double totTime = elapsed / 1000;
            System.out.print("Tempo trascorso: ");
            System.out.print(totTime);
            System.out.println();

        } else {
            System.out.println("Wrong input!!");
        }

	}



    /**
     * Test
     */
    public static void testMultiMixed2() {

        System.out.println("Sistema misto con 2 classi");
        long start = System.currentTimeMillis();

        int[] classTypes = new int[2];
        classTypes[0] = SolverMulti.CLOSED_CLASS;
        classTypes[1] = SolverMulti.CLOSED_CLASS;

        double[] classData = new double[2];
        classData[0] = 5;
        classData[1] = 10;

		SolverMultiMixed multiMixed = new SolverMultiMixed(2, 2);

        String[] name = {"Station1", "Station2"};
		int[] type = {Solver.LI, Solver.LI};
		double[][][] servt = new double[2][2][1];

		//station 1
        servt[0][0][0] = 0.002;
        servt[0][1][0] = 0.005;

        //station 2
        servt[1][0][0] = 0.003;
        servt[1][1][0] = 0.004;


        double[][] visits = new double[2][2];

        //station 1
        visits[0][0] = 5;
        visits[0][1] = 5;

        //station 2
        visits[1][0] = 1;
        visits[1][1] = 3;


		if (multiMixed.input(name, type, servt, visits, classData, classTypes)){

            multiMixed.solve();
            System.out.println(multiMixed);
            System.out.println("End Multi mixed");
            long stop = System.currentTimeMillis();
            long elapsed = stop - start;
            double totTime = elapsed / 1000;
            System.out.print("Tempo trascorso: ");
            System.out.print(totTime);
            System.out.println();

        } else {
            System.out.println("Wrong input!!");
        }

	}



    /**
     * Test
     */
    public static void testMultiMixed3() {

        System.out.println("Sistema misto con 2 classi");
        long start = System.currentTimeMillis();

        int[] classTypes = new int[2];
        classTypes[0] = SolverMulti.CLOSED_CLASS;
        classTypes[1] = SolverMulti.OPEN_CLASS;

        double[] classData = new double[2];
        classData[0] = 5;
        classData[1] = 0.04;

		SolverMultiMixed multiMixed = new SolverMultiMixed(2, 2);

        String[] name = {"Station1", "Station2"};
		int[] type = {Solver.DELAY, Solver.DELAY};
		double[][][] servt = new double[2][2][1];

		//station 1
        servt[0][0][0] = 2;
        servt[0][1][0] = 3;

        //station 2
        servt[1][0][0] = 1;
        servt[1][1][0] = 8;


        double[][] visits = new double[2][2];

        //station 1
        visits[0][0] = 1;
        visits[0][1] = 1;

        //station 2
        visits[1][0] = 1;
        visits[1][1] = 1;


		if (multiMixed.input(name, type, servt, visits, classData, classTypes)){

            multiMixed.solve();
            System.out.println(multiMixed);
            System.out.println("End Multi mixed");
            long stop = System.currentTimeMillis();
            long elapsed = stop - start;
            double totTime = elapsed / 1000;
            System.out.print("Tempo trascorso: ");
            System.out.print(totTime);
            System.out.println();

        } else {
            System.out.println("Wrong input!!");
        }

	}



   /**
     * Test
     */
    public static void testMultiMixed_4C_2S() {

       System.out.println("Sistema misto con 4 classi");
       long start = System.currentTimeMillis();

       int[] classTypes = new int[4];
       classTypes[0] = SolverMulti.OPEN_CLASS;
       classTypes[1] = SolverMulti.OPEN_CLASS;
       classTypes[2] = SolverMulti.CLOSED_CLASS;
       classTypes[3] = SolverMulti.CLOSED_CLASS;

       double[] classData = new double[4];
       classData[0] = 0.005;
       classData[1] = 0.008;
       classData[2] = 20;
       classData[3] = 10;

       SolverMultiMixed multiMixed = new SolverMultiMixed(4, 2);

       String[] name = {"Station1", "Station2"};
       int[] type = {Solver.LI, Solver.LI};
       double[][][] servt = new double[2][4][1];

       //station 1
       servt[0][0][0] = 5;
       servt[0][1][0] = 10;
       servt[0][2][0] = 10;
       servt[0][3][0] = 3;

       //station 2
       servt[1][0][0] = 4;
       servt[1][1][0] = 3;
       servt[1][2][0] = 5;
       servt[1][3][0] = 6;