Пример #1
0
        public static IArtaProcess CreateArtaProcess(double[] data)// throws NonFeasibleCorrelationException, NotStationaryException
        {
            EmpiricalDistribution distribution = new EmpiricalDistribution(data);
            int order = OrderEstimator.EstimateOrder(data);

            Console.WriteLine("order" + order);
            double[] artaCorrelationCoefficients = new double[AutoCorrelation.CalculateAcfs(data, order).Length];
            Array.ConstrainedCopy(AutoCorrelation.CalculateAcfs(data, order), 1, artaCorrelationCoefficients, 1, order + 1);
            return(CreateArtaProcess(distribution, artaCorrelationCoefficients, new RandomAdaptor(new MersenneTwister())));
        }
Пример #2
0
        private void Execute(object obj)
        {
            ErrorIsVisible = Visibility.Hidden;
            if (!InputIsValid())
            {
                return;
            }
            ArtaNumbers.Clear();
            Acfs.Clear();
            Pacfs.Clear();

            try
            {
                var context     = new ArtaExecutionContext((ArtaExecutionContext.Distribution)Distribution, new double[] { correlationCoefficient });
                var artaProcess = context.ArtaProcess;
                artaNumbers = new double[iterations];
                artaNumbers = new double[iterations];

                for (var i = 0; i < Iterations; i++)
                {
                    artaNumbers[i] = artaProcess.Next();
                    ArtaNumbers.Add(new ListHelper(artaNumbers[i], 0, 0));
                }

                acfs = AutoCorrelation.CalculateAcfs(artaNumbers, lag);
                foreach (var item in acfs)
                {
                    Acfs.Add(new ListHelper(0, item, 0));
                }

                pacfs = AutoCorrelation.CalculatePacfs(acfs);
                foreach (var item in pacfs)
                {
                    Pacfs.Add(new ListHelper(0, 0, item));
                }
                Order           = OrderEstimator.EstimateOrder(artaNumbers, lag);
                ExportIsEnabled = true;
            }
            catch (Exception exception)
            {
                ErrorMessage   = exception.Message;
                ErrorIsVisible = Visibility.Visible;
            }
        }
Пример #3
0
        public static void Main(String[] args)
        {
            RealDistribution distribution = new ExponentialDistribution(1.0);

            double[]     artaCorrelationCoefficients = { 0.3, 0.3, -0.1 };
            IArtaProcess arta = ArtaProcessFactory.CreateArtaProcess(distribution, artaCorrelationCoefficients);

            double[] data = new double[10000];
            for (int i = 0; i < data.Length; i++)
            {
                data[i] = arta.Next();
            }


            int maxLag = 10;

            double[] acfs  = AutoCorrelation.CalculateAcfs(data, maxLag);
            double[] pacfs = AutoCorrelation.CalculatePacfs(acfs);

            Console.WriteLine("#########################");
            Console.WriteLine("ACFS");
            foreach (double d in acfs)
            {
                Console.WriteLine(d.ToString());
            }
            Console.WriteLine('\n');

            Console.WriteLine("#########################");
            Console.WriteLine("PACFS");
            foreach (double d in pacfs)
            {
                Console.WriteLine(d);
            }
            Console.WriteLine('\n');

            Console.WriteLine("#########################");
            Console.WriteLine("Order");
            Console.WriteLine(OrderEstimator.EstimateOrder(data, maxLag));
        }
Пример #4
0
 public void PrintOrder()
 {
     order = OrderEstimator.EstimateOrder(artaNumbers, lag);
     Console.WriteLine("###############################################\n");
     Console.WriteLine("Order: {0}", order);
 }
 public ArtaStatistics Order()
 {
     order      = OrderEstimator.EstimateOrder(artaNumbers, lag);
     printOrder = true;
     return(this);
 }