Airy or Not Airy: Thats the question

Indicateurs d'AlphaTrader
Avatar de l’utilisateur
QUASAR
Messages : 285
Inscription : lun. sept. 24, 2012 3:27 am
Contact :

Messagepar QUASAR » ven. nov. 29, 2013 3:56 pm

Bonjours folks,

Je suis tombé sur une équation différentielle qui simule un système oscillant vers un jet exponentiel. Voici l'image wikipedia.
http://en.wikipedia.org/wiki/Airy_function


On calcul l'écart type des valeurs, leurs accroissements, la vitesse du changement des écarts type est alors la variable x qui est satisfaites par les solutions de cette equation différentielle .
l'idée est un simulation et une projection de cette solution ce qui permmettrai de décides dans un certain interval de confiance si on va choisir un retour à la moyenne ou la médiane ou bien alors un suivi de tendance.
Qu'est ce que vous en pensez les gars?

Avatar de l’utilisateur
QUASAR
Messages : 285
Inscription : lun. sept. 24, 2012 3:27 am
Contact :

Messagepar QUASAR » dim. déc. 01, 2013 10:30 am

voici un debut de code si il y en a qui sont chaud pour le terminer avec moi ........


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using TicTacTec.TA.Library;
using System.Drawing;
using AlphaAPI;
using AlphaUtils;

namespace MyAlgos.Ind
{
public class Airy2 : Indicator
{
private int m_iPeriod = 12;
[Description("Period")]
public int Period
{
get { return m_iPeriod; }
set { m_iPeriod = Math.Max(value, 1); }
}

private int m_iDeviation = 2;
[Description("Deviation")]
public int Deviation
{
get { return m_iDeviation; }
set { m_iDeviation = Math.Abs(value); }
}
public BarField m_ApplyTo1 = BarField.Close;
public BarField ApplyTo1
{
get { return m_ApplyTo1; }
set { m_ApplyTo1 = value; }
}

///
/// Define here the output buffers of this Indicator
/// Note: the output of NewUpdate() MUST be formatted according to the buffers defined here
/// - There must be the same number of buffers
/// - The buffers out of NewUpdate() must be in the same order as the buffer definition in here
///

public override void DefineBuffers()
{
IsOnlyForBar = true;
AddBuffer("ecartAiry", Location.NewArea);
}

///
/// Define the required History (Bars and Ticks) of this Indicator
///

public override void DefineHistory()
{
GetBarSequence(33000);

AddBarSubscription(Tempo, 33000);

}

///
/// Override to explain how the Indicator performs its tasks. This is the core function of an Indicator.
///

/// The new buffer to add to Indicator data, or null if there is no new value
public override decimal[] OnUpdate()
{
IBar[] bars = GetBarSequence(Period);
IBar[] Bars = GetBarSequence(10000);
ITick tick = CurrentTick;
ITick[] ticksequence = GetTickSequence(1000);
Double[] Close = Bars.Prices(ApplyTo1).Decimal2Double();

double[] derivéeUne = new double[Close.Count()];
double[] derivéeDeux = new double[Close.Count()];
double[] ecartmin = new double[Close.Count()];

int valeurindicetick = 1;
double[] fonctionAiry = new double[(Close.Count() - 16) / valeurindicetick];
// on assume qu on possede le nombre de ticks, on cree artificellement un intervalle de tick
//on construit une fonction centree reduite ou le log return ou l ecart mean - median
for (int i = 15; i < Close.Count() - 16; i++)
{
derivéeUne[i] = Close[i] - Close[i - 15];

}
for (int j = 0; j < Close.Count() - 16; j++)
{
if (j>0 && derivéeUne[j] - derivéeUne[j - 1] >= double.MinValue)
{
derivéeDeux[j] = derivéeUne[j] - derivéeUne[j - 1];
}
else
{
for (int k = 0; k < Close.Count() - 16; k++)
{
ecartmin[k] = derivéeUne[0] - derivéeUne[k];
if (ecartmin[k] >= double.MinValue)
{
valeurindicetick = k;
derivéeDeux[j] = ecartmin[k];
}
}

}
}
if (valeurindicetick > 0)
{
fonctionAiry[0] = derivéeDeux[valeurindicetick] - valeurindicetick * (double)Close[0];

}
double SolStationnaire = 0;
double SolTransitoire = 0;
//if (fonctionAiry[0] == 0)
//{
for (int p = 0; p < (Close.Count() - 16) / valeurindicetick; p++)
{
SolStationnaire += 1 / (Math.PI) * (Math.Cos((Math.Pow(p, 3)) / 3 + Close[0] * p));
SolTransitoire += 1 / (Math.PI) * (Math.Sin((Math.Pow(p, 3)) / 3 + Close[0] * p))
+ Math.Exp((Math.Pow(-p / 3, 3)));
}


//}
//else
//{



//}

double ecartAiry = Math.Abs(SolStationnaire - SolTransitoire);

// dans la strat
//if (ecartAiry >= double.MinValue)
//{

// if (ecartAiry > 0.15)
// {

// }
//}
// calculate MA

//double deriveOrdre1(t i) = Close[i] - Close[i - 1] / (t(i) - t(i - 1));
//double deriveOrdre1(t i-1) = Close[i-1] - Close[i - 2] / (t(i-1) - t(i - 2));

//double deriveordre2(t i) = (deriveOrdre1(t i)-deriveOrdre1(t i-1))/(ti - ti-1);

//tel que i - i -1 ->> epsilon.( exemple 1 tick);





decimal[] buffer = new decimal[] { (Decimal)Math.Round(ecartAiry,7)

};

return (buffer);
}
}
}

tutu
Messages : 388
Inscription : mar. févr. 21, 2012 7:13 pm

Messagepar tutu » dim. déc. 01, 2013 11:45 am

Salut,
je ne sais pas si l'on peut lier R avec Alpha, mais la fonction existe déjà dans R et te permettrait ainsi d'éviter à la "réinventer".

Avatar de l’utilisateur
QUASAR
Messages : 285
Inscription : lun. sept. 24, 2012 3:27 am
Contact :

Messagepar QUASAR » dim. déc. 01, 2013 12:16 pm

oui on peut mais je ne veux pas passer RDOTNET.

Avatar de l’utilisateur
surfeur
Messages : 931
Inscription : ven. févr. 19, 2010 1:43 am
Localisation : France

Messagepar surfeur » mar. nov. 11, 2014 11:10 pm

Quasar tu as quoi contre RDOTNET ? justement je suis entrain de regarder pour connecter R a Alpha :)


Revenir vers « Indicateurs »

Qui est en ligne ?

Utilisateurs parcourant ce forum : Aucun utilisateur inscrit et 1 invité