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);
}
