public ArtaStatistics Excecute() { artaNumbers = new double[iterations]; for (int i = 0; i < iterations; i++) { artaNumbers[i] = context.ArtaProcess.Next(); } acfs = AutoCorrelation.CalculateAcfs(artaNumbers, lag); PrintBasicInformation(); if (printAcfs) { PrintAcfs(); } if (printPacfs) { PrintPacfs(); } if (printOrder) { PrintOrder(); } if (printArtaNumbers) { PrintArtanumbers(); } if (printArnumbers) { PrintArnumbers(); } return(this); }
public static IArtaProcess CreateArtaProcess(RealDistribution distribution, double[] artaCorrelationCoefficients, RandomGenerator random) //throws NonFeasibleCorrelationException, NotStationaryException { AbstractArtaProcess arta = null; if (artaCorrelationCoefficients == null || artaCorrelationCoefficients.Length == 0) { double[] noCorrelation = { 0.0 }; artaCorrelationCoefficients = noCorrelation; } // check feasibility FeasibilityTest ft = new FeasibilityTest(distribution); ft.CheckFeasibility(artaCorrelationCoefficients); // check if correlation matrix is positive definite, if not CholeskyDecomposition throws Error new CholeskyDecomposition(AutoCorrelation.GetCorrelationMatrix(artaCorrelationCoefficients)); if (distribution is NormalDistribution) { arta = CreateArtaProcessN((NormalDistribution)distribution, artaCorrelationCoefficients, random); } else if (distribution is UniformRealDistribution) { arta = createArtaProcessU((UniformRealDistribution)distribution, artaCorrelationCoefficients, random); } else { arta = CreateArtaProcessG(distribution, artaCorrelationCoefficients, random); } return(arta); }
private IArtaProcess CreateArtaProcess() { if (ArtaCorrelationCoefficients == null) { ArtaCorrelationCoefficients = new double[] { 0.0 }; } AutoCorrelation.GetCorrelationMatrix(ArtaCorrelationCoefficients).Cholesky(); return(distribution.CreateArtaProcess(ArtaCorrelationCoefficients, new MersenneTwister())); }
public void PrintPacfs() { pacfs = AutoCorrelation.CalculatePacfs(acfs); Console.WriteLine("###############################################\n"); Console.WriteLine("PACFS:"); foreach (var num in pacfs) { Console.WriteLine(num); } }
public void PrintAcfs() { acfs = AutoCorrelation.CalculateAcfs(artaNumbers, lag); Console.WriteLine("###############################################\n"); Console.WriteLine("ACFS:"); foreach (var num in acfs) { Console.WriteLine(num); } }
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()))); }
public static double[] ArAutocorrelationsToAlphas(double[] arAutocorrelations) { var dim = arAutocorrelations.Length; var alphas = new double[dim]; var psi = AutoCorrelation.GetCorrelationMatrix(arAutocorrelations); var r = CreateMatrix.DenseOfColumnArrays(arAutocorrelations).Transpose(); var a = r.Multiply(psi.Cholesky().Solve(psi).Inverse()); alphas = a.Row(0).AsArray(); return(alphas); }
/** * Determines the coefficients (alpha) for the ARTA-Process. * */ public static double[] ArAutocorrelationsToAlphas(double[] arAutocorrelations) { int dim = arAutocorrelations.Length; double[] alphas = new double[dim]; RealMatrix psi = AutoCorrelation.GetCorrelationMatrix(arAutocorrelations); RealMatrix r = new Array2DRowRealMatrix(arAutocorrelations).transpose(); RealMatrix a = r.multiply(new CholeskyDecomposition(psi).getSolver().getInverse()); alphas = a.getRow(0); return(alphas); }
public static int EstimateOrder(double[] data, int maxOrder) { double significanceLevel = 2 / Math.Sqrt(data.Length); int order = maxOrder; double[] acfs = AutoCorrelation.CalculateAcfs(data, maxOrder); double[] pacfs = AutoCorrelation.CalculatePacfs(acfs); for (int i = 0; i < maxOrder; i++) { if (Math.Abs(pacfs[i + 1]) < significanceLevel) { return(i); } } return(order); }
public static int EstimateOrder(double[] data, int maxOrder) { var significanceLevel = 2 / System.Math.Sqrt(data.Length); var order = maxOrder; var acfs = AutoCorrelation.CalculateAcfs(data, maxOrder); var pacfs = AutoCorrelation.CalculatePacfs(acfs); for (var i = 0; i < maxOrder; i++) { if (System.Math.Abs(pacfs[i + 1]) < significanceLevel) { return(i); } } return(order); }
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; } }
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)); }
public ArtaStatistics CorrelationMatrix() { AutoCorrelation.GetCorrelationMatrix(context.ArtaCorrelationCoefficients); return(this); }
public ArtaStatistics Pacfs() { acfs = AutoCorrelation.CalculateAcfs(artaNumbers, lag); printPacfs = true; return(this); }
public ActionResult Index( long[] matterIds, short[] characteristicLinkIds, int length, int step, bool delta, bool fourier, bool growingWindow, bool autocorrelation, Notation notation, Language?language, Translator?translator, PauseTreatment?pauseTreatment, bool?sequentialTransfer, ImageOrderExtractor?trajectory) { return(CreateTask(() => { var characteristicNames = new string[characteristicLinkIds.Length]; var partNames = new List <string> [matterIds.Length]; var starts = new List <int> [matterIds.Length]; var lengthes = new List <int> [matterIds.Length]; var chains = new Chain[matterIds.Length]; var mattersCharacteristics = new object[matterIds.Length]; var calculators = new IFullCalculator[characteristicLinkIds.Length]; var links = new Link[characteristicLinkIds.Length]; matterIds = matterIds.OrderBy(m => m).ToArray(); Dictionary <long, Matter> matters = Cache.GetInstance().Matters.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id); for (int k = 0; k < matterIds.Length; k++) { long matterId = matterIds[k]; Nature nature = Cache.GetInstance().Matters.Single(m => m.Id == matterId).Nature; long sequenceId = commonSequenceRepository.GetSequenceIds(new[] { matterId }, notation, language, translator, pauseTreatment, sequentialTransfer, trajectory).Single(); chains[k] = commonSequenceRepository.GetLibiadaChain(sequenceId); } for (var i = 0; i < characteristicLinkIds.Length; i++) { int characteristicLinkId = characteristicLinkIds[i]; FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId); calculators[i] = FullCalculatorsFactory.CreateCalculator(characteristic); links[i] = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId); } for (int i = 0; i < chains.Length; i++) { CutRule cutRule = growingWindow ? (CutRule) new CutRuleWithFixedStart(chains[i].Length, step) : new SimpleCutRule(chains[i].Length, step, length); CutRuleIterator iterator = cutRule.GetIterator(); var fragments = new List <Chain>(); partNames[i] = new List <string>(); starts[i] = new List <int>(); lengthes[i] = new List <int>(); while (iterator.Next()) { int start = iterator.GetStartPosition(); int end = iterator.GetEndPosition(); var fragment = new List <IBaseObject>(); for (int k = 0; start + k < end; k++) { fragment.Add(chains[i][start + k]); } fragments.Add(new Chain(fragment)); partNames[i].Add(fragment.ToString()); starts[i].Add(iterator.GetStartPosition()); lengthes[i].Add(fragment.Count); } var fragmentsData = new FragmentData[fragments.Count]; for (int k = 0; k < fragments.Count; k++) { var characteristics = new double[calculators.Length]; for (int j = 0; j < calculators.Length; j++) { characteristics[j] = calculators[j].Calculate(fragments[k], links[j]); } fragmentsData[k] = new FragmentData(characteristics, fragments[k].ToString(), starts[i][k], fragments[k].Length); } double[][] differenceData = null; double[][] fourierData = null; double[][] autocorrelationData = null; if (delta) { differenceData = CalculateDifference(fragmentsData.Select(f => f.Characteristics).ToArray()); } if (fourier) { fourierData = FastFourierTransform.CalculateFastFourierTransform(fragmentsData.Select(f => f.Characteristics).ToArray()); } if (autocorrelation) { autocorrelationData = AutoCorrelation.CalculateAutocorrelation(fragmentsData.Select(f => f.Characteristics).ToArray()); } mattersCharacteristics[i] = new LocalCharacteristicsData(matters[matterIds[i]].Name, fragmentsData, differenceData, fourierData, autocorrelationData); } for (int l = 0; l < characteristicLinkIds.Length; l++) { characteristicNames[l] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[l]); } var characteristicsList = new SelectListItem[characteristicLinkIds.Length]; for (int k = 0; k < characteristicLinkIds.Length; k++) { characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k], notation); characteristicsList[k] = new SelectListItem { Value = k.ToString(), Text = characteristicNames[k], Selected = false }; } var result = new Dictionary <string, object> { { "characteristics", mattersCharacteristics }, { "notationName", notation.GetDisplayValue() }, { "starts", starts }, { "partNames", partNames }, { "lengthes", lengthes }, { "characteristicNames", characteristicNames }, { "matterIds", matterIds }, { "characteristicsList", characteristicsList }, { "aligners", EnumHelper.GetSelectList(typeof(Aligner)) }, { "distanceCalculators", EnumHelper.GetSelectList(typeof(DistanceCalculator)) }, { "aggregators", EnumHelper.GetSelectList(typeof(Aggregator)) } }; return new Dictionary <string, string> { { "data", JsonConvert.SerializeObject(result) } }; })); }
public ArtaStatistics Pacfs() { pacfs = AutoCorrelation.CalculatePacfs(acfs); printPacfs = true; return(this); }