CODES NINJA TRADER

**fcetrader31** · 05/01/2010, 21:14

Bonsoir Sergi,

Donne moi ton mail, je t'envoie les codes du STPMT et du repulse prêts à être importés dans Ninjatrader.

A+
Fcetrader

**sergi** · 06/01/2010, 18:25

up

**ad2r** · 06/01/2010, 19:15

bonjour,

STPMT :

*********************************

#region Using declarations
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Xml.Serialization;
using NinjaTrader.Cbi;
using NinjaTrader.Data;
using NinjaTrader.Gui.Chart;
#endregion

// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
/// <summary>
/// Indicateur STPMT d'E.Lefort
/// </summary>
[Description("Indicateur STPMT d'E.Lefort")]
public class STPMT : Indicator
{
#region Variables
// Wizard generated variables
private int periodM = 9; // Default setting for PeriodM (Periode de la Moyenne mobile simple de la STPMT)
// User defined variables (add any user defined variables below)
private DataSeries K1;
private DataSeries K2;
private DataSeries K3;
private DataSeries K4;
private DataSeries nom1;
private DataSeries nom2;
private DataSeries nom3;
private DataSeries nom4;
private DataSeries den1;
private DataSeries den2;
private DataSeries den3;
private DataSeries den4;
#endregion

/// <summary>
/// This method is used to configure the indicator and is called once before any bar data is loaded.
/// </summary>
protected override void Initialize()
{
Add(new Plot(new Pen(Color.Blue, 2), "Stpmt"));
Add(new Plot(new Pen(Color.Red, 2), "MM9_Stpmt"));
Add(new Plot(Color.Green, PlotStyle.Line, "Stoch1"));
Add(new Plot(Color.Orange, PlotStyle.Line, "Stoch2"));
Add(new Plot(Color.Magenta, PlotStyle.Line, "Stoch3"));
Add(new Plot(Color.DarkViolet, PlotStyle.Line, "Stoch4"));
Add(new Line(Color.FromKnownColor(KnownColor.Gray), 50, "Ligne50"));
Add(new Line(Color.FromKnownColor(KnownColor.Gray), 80, "Ligne80"));
Add(new Line(Color.FromKnownColor(KnownColor.Gray), 20, "Ligne20"));

CalculateOnBarClose = false;
Overlay = false;
PriceTypeSupported = false;
AutoScale = true;

K1 = new DataSeries(this);
K2 = new DataSeries(this);
K3 = new DataSeries(this);
K4 = new DataSeries(this);
den1 = new DataSeries(this);
den2 = new DataSeries(this);
den3 = new DataSeries(this);
den4 = new DataSeries(this);
nom1 = new DataSeries(this);
nom2 = new DataSeries(this);
nom3 = new DataSeries(this);
nom4 = new DataSeries(this);
}

/// <summary>
/// Called on each bar update event (incoming tick)
/// </summary>
protected override void OnBarUpdate()
{
// Calcule le Stochastique (5,3)
nom1.Set(Close[0] - MIN(Low, 5)[0]);
den1.Set(MAX(High, 5)[0] - MIN(Low, 5)[0]);
K1.Set(100 * nom1[0] / (den1[0] == 0 ? 1.0 : den1[0]));
Stoch1.Set(SMA(K1, 3)[0]);

// Calcule le Stochastique (14,3)
nom2.Set(Close[0] - MIN(Low, 14)[0]);
den2.Set(MAX(High, 14)[0] - MIN(Low, 14)[0]);
K2.Set(100 * nom2[0] / (den2[0] == 0 ? 1.0 : den2[0]));
Stoch2.Set(SMA(K2, 3)[0]);

// Calcule le Stochastique (45,14)
nom3.Set(Close[0] - MIN(Low, 45)[0]);
den3.Set(MAX(High, 45)[0] - MIN(Low, 45)[0]);
K3.Set(100 * nom3[0] / (den3[0] == 0 ? 1.0 : den3[0]));
Stoch3.Set(SMA(K3, 14)[0]);

// Calcule le Stochastique (75,20)
nom4.Set(Close[0] - MIN(Low, 75)[0]);
den4.Set(MAX(High, 75)[0] - MIN(Low, 75)[0]);
K4.Set(100 * nom4[0] / (den4[0] == 0 ? 1.0 : den4[0]));
Stoch4.Set(SMA(K4, 20)[0]);

// Calcule l'indicateur STPMT (formule d'E.Lefort)

Stpmt.Set((4.1*Stoch1[0]+2.5*Stoch2[0]+Stoch3[0]+4.0*Stoch4[0])/11.6);

// Calcule la moyenne mobile simple 9 périodes du STPMT

MM9_Stpmt.Set(SMA(Stpmt,periodM)[0]);
}

#region Properties
[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Stpmt
{
get { return Values[0]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries MM9_Stpmt
{
get { return Values[1]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Stoch1
{
get { return Values[2]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Stoch2
{
get { return Values[3]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Stoch3
{
get { return Values[4]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Stoch4
{
get { return Values[5]; }
}

[Description("Periode de la moyenne mobile de la STPMT")]
[Category("Parameters")]
public int PeriodM
{
get { return periodM; }
set { periodM = Math.Max(1, value); }
}
#endregion
}
}

#region NinjaScript generated code. Neither change nor remove.
// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
public partial class Indicator : IndicatorBase
{
private STPMT[] cacheSTPMT = null;

private static STPMT checkSTPMT = new STPMT();

/// <summary>
/// Indicateur STPMT d'E.Lefort
/// </summary>
/// <returns></returns>
public STPMT STPMT(int periodM)
{
return STPMT(Input, periodM);
}

/// <summary>
/// Indicateur STPMT d'E.Lefort
/// </summary>
/// <returns></returns>
public STPMT STPMT(Data.IDataSeries input, int periodM)
{
checkSTPMT.PeriodM = periodM;
periodM = checkSTPMT.PeriodM;

if (cacheSTPMT != null)
for (int idx = 0; idx < cacheSTPMT.Length; idx++)
if (cacheSTPMT[idx].PeriodM == periodM && cacheSTPMT[idx].EqualsInput(input))
return cacheSTPMT[idx];

STPMT indicator = new STPMT();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
indicator.Input = input;
indicator.PeriodM = periodM;
indicator.SetUp();

STPMT[] tmp = new STPMT[cacheSTPMT == null ? 1 : cacheSTPMT.Length + 1];
if (cacheSTPMT != null)
cacheSTPMT.CopyTo(tmp, 0);
tmp[tmp.Length - 1] = indicator;
cacheSTPMT = tmp;
Indicators.Add(indicator);

return indicator;
}

}
}

// This namespace holds all market analyzer column definitions and is required. Do not change it.
namespace NinjaTrader.MarketAnalyzer
{
public partial class Column : ColumnBase
{
/// <summary>
/// Indicateur STPMT d'E.Lefort
/// </summary>
/// <returns></returns>
[Gui.Design.WizardCondition("Indicator")]
public Indicator.STPMT STPMT(int periodM)
{
return _indicator.STPMT(Input, periodM);
}

/// <summary>
/// Indicateur STPMT d'E.Lefort
/// </summary>
/// <returns></returns>
public Indicator.STPMT STPMT(Data.IDataSeries input, int periodM)
{
return _indicator.STPMT(input, periodM);
}

}
}

// This namespace holds all strategies and is required. Do not change it.
namespace NinjaTrader.Strategy
{
public partial class Strategy : StrategyBase
{
/// <summary>
/// Indicateur STPMT d'E.Lefort
/// </summary>
/// <returns></returns>
[Gui.Design.WizardCondition("Indicator")]
public Indicator.STPMT STPMT(int periodM)
{
return _indicator.STPMT(Input, periodM);
}

/// <summary>
/// Indicateur STPMT d'E.Lefort
/// </summary>
/// <returns></returns>
public Indicator.STPMT STPMT(Data.IDataSeries input, int periodM)
{
if (InInitialize && input == null)
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");

return _indicator.STPMT(input, periodM);
}

}
}
#endregion

**************************************************

Repulse :

***************************************************

#region Using declarations
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Xml.Serialization;
using NinjaTrader.Cbi;
using NinjaTrader.Data;
using NinjaTrader.Gui.Chart;
#endregion

// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
/// <summary>
/// Enter the description of your new custom indicator here
/// </summary>
[Description("Indicateur Repulse d'E.Lefort")]
public class Repulse : Indicator
{
#region Variables
// Wizard generated variables
private int period1 = 1; // Default setting for Period1
private int period2 = 5; // Default setting for Period2
private int period3 = 15; // Default setting for Period3
// User defined variables (add any user defined variables below)
private DataSeries bullishthrust1;
private DataSeries bullishthrust2;
private DataSeries bullishthrust3;
private DataSeries bearishthrust1;
private DataSeries bearishthrust2;
private DataSeries bearishthrust3;

#endregion

/// <summary>
/// This method is used to configure the indicator and is called once before any bar data is loaded.
/// </summary>
protected override void Initialize()
{
Add(new Plot(Color.FromKnownColor(KnownColor.Red), PlotStyle.Line, "Repulse1"));
Add(new Plot(Color.FromKnownColor(KnownColor.Blue), PlotStyle.Line, "Repulse2"));
Add(new Plot(Color.FromKnownColor(KnownColor.Orange), PlotStyle.Line, "Repulse3"));
Add(new Line(Color.FromKnownColor(KnownColor.Black), 0, "Zeroline"));
CalculateOnBarClose = false;
Overlay = false;
PriceTypeSupported = false;

bullishthrust1 = new DataSeries(this);
bullishthrust2 = new DataSeries(this);
bullishthrust3 = new DataSeries(this);
bearishthrust1 = new DataSeries(this);
bearishthrust2 = new DataSeries(this);
bearishthrust3 = new DataSeries(this);

}

/// <summary>
/// Called on each bar update event (incoming tick)
/// </summary>
protected override void OnBarUpdate()
{ if (CurrentBar<15)
return;
else
{
int p1=5*period1;
int p2=5*period2;
int p3=5*period3;
double myHigh1=MAX(High,period1)[0];
double myHigh2=MAX(High,period2)[0];
double myHigh3=MAX(High,period3)[0];
double myLow1=MIN(Low,period1)[0];
double myLow2=MIN(Low,period2)[0];
double myLow3=MIN(Low,period3)[0];
bullishthrust1.Set((3*Close[0]-2*myLow1-Open[period1])/Close[0]*100);
bullishthrust2.Set((3*Close[0]-2*myLow2-Open[period2])/Close[0]*100);
bullishthrust3.Set((3*Close[0]-2*myLow3-Open[period3])/Close[0]*100);
bearishthrust1.Set((Open[period1]+2*myHigh1-3*Close[0])/Close[0]*100);
bearishthrust2.Set((Open[period2]+2*myHigh2-3*Close[0])/Close[0]*100);
bearishthrust3.Set((Open[period3]+2*myHigh3-3*Close[0])/Close[0]*100);

double mm1=EMA(bullishthrust1,p1)[0];
double mm2=EMA(bullishthrust2,p2)[0];
double mm3=EMA(bullishthrust3,p3)[0];
double mb1=EMA(bearishthrust1,p1)[0];
double mb2=EMA(bearishthrust2,p2)[0];
double mb3=EMA(bearishthrust3,p3)[0];

// Use this method for calculating your indicator values. Assign a value to each
// plot below by replacing 'Close[0]' with your own formula.
Repulse1.Set(mm1-mb1);
Repulse2.Set(mm2-mb2);
Repulse3.Set(mm3-mb3);
}
}

#region Properties
[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Repulse1
{
get { return Values[0]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Repulse2
{
get { return Values[1]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Repulse3
{
get { return Values[2]; }
}

[Description("")]
[Category("Parameters")]
public int Period1
{
get { return period1; }
set { period1 = Math.Max(1, value); }
}

[Description("")]
[Category("Parameters")]
public int Period2
{
get { return period2; }
set { period2 = Math.Max(1, value); }
}

[Description("")]
[Category("Parameters")]
public int Period3
{
get { return period3; }
set { period3 = Math.Max(1, value); }
}
#endregion
}
}

#region NinjaScript generated code. Neither change nor remove.
// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
public partial class Indicator : IndicatorBase
{
private Repulse[] cacheRepulse = null;

private static Repulse checkRepulse = new Repulse();

/// <summary>
/// Indicateur Repulse d'E.Lefort
/// </summary>
/// <returns></returns>
public Repulse Repulse(int period1, int period2, int period3)
{
return Repulse(Input, period1, period2, period3);
}

/// <summary>
/// Indicateur Repulse d'E.Lefort
/// </summary>
/// <returns></returns>
public Repulse Repulse(Data.IDataSeries input, int period1, int period2, int period3)
{
checkRepulse.Period1 = period1;
period1 = checkRepulse.Period1;
checkRepulse.Period2 = period2;
period2 = checkRepulse.Period2;
checkRepulse.Period3 = period3;
period3 = checkRepulse.Period3;

if (cacheRepulse != null)
for (int idx = 0; idx < cacheRepulse.Length; idx++)
if (cacheRepulse[idx].Period1 == period1 && cacheRepulse[idx].Period2 == period2 && cacheRepulse[idx].Period3 == period3 && cacheRepulse[idx].EqualsInput(input))
return cacheRepulse[idx];

Repulse indicator = new Repulse();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
indicator.Input = input;
indicator.Period1 = period1;
indicator.Period2 = period2;
indicator.Period3 = period3;
indicator.SetUp();

Repulse[] tmp = new Repulse[cacheRepulse == null ? 1 : cacheRepulse.Length + 1];
if (cacheRepulse != null)
cacheRepulse.CopyTo(tmp, 0);
tmp[tmp.Length - 1] = indicator;
cacheRepulse = tmp;
Indicators.Add(indicator);

return indicator;
}

}
}

// This namespace holds all market analyzer column definitions and is required. Do not change it.
namespace NinjaTrader.MarketAnalyzer
{
public partial class Column : ColumnBase
{
/// <summary>
/// Indicateur Repulse d'E.Lefort
/// </summary>
/// <returns></returns>
[Gui.Design.WizardCondition("Indicator")]
public Indicator.Repulse Repulse(int period1, int period2, int period3)
{
return _indicator.Repulse(Input, period1, period2, period3);
}

/// <summary>
/// Indicateur Repulse d'E.Lefort
/// </summary>
/// <returns></returns>
public Indicator.Repulse Repulse(Data.IDataSeries input, int period1, int period2, int period3)
{
return _indicator.Repulse(input, period1, period2, period3);
}

}
}

// This namespace holds all strategies and is required. Do not change it.
namespace NinjaTrader.Strategy
{
public partial class Strategy : StrategyBase
{
/// <summary>
/// Indicateur Repulse d'E.Lefort
/// </summary>
/// <returns></returns>
[Gui.Design.WizardCondition("Indicator")]
public Indicator.Repulse Repulse(int period1, int period2, int period3)
{
return _indicator.Repulse(Input, period1, period2, period3);
}

/// <summary>
/// Indicateur Repulse d'E.Lefort
/// </summary>
/// <returns></returns>
public Indicator.Repulse Repulse(Data.IDataSeries input, int period1, int period2, int period3)
{
if (InInitialize && input == null)
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");

return _indicator.Repulse(input, period1, period2, period3);
}

}
}
#endregion

****************************************************

**Jean-Phi** · 07/01/2010, 09:11

Bonjour,

Ci-après, vous trouverez le code pour la MACD JL (marche pour NT6.5 et NT7)
<center><img src='http://images.pro-at.com/forums-bourse/0110/25828_071011.jpg' alt='' /></center>

**Jean-Phi** · 07/01/2010, 09:14

MACDJL

<font color='#056001'>//
// Copyright (C) 2006, NinjaTrader LLC <www.ninjatrader.com>.
// NinjaTrader reserves the right to modify or overwrite this NinjaScript component with each release.
//

#region Using declarations
using System;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.ComponentModel;
using System.Xml.Serialization;
using NinjaTrader.Data;
using NinjaTrader.Gui.Chart;
#endregion

// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
/// <summary>
/// The MACDJL (Moving Average Convergence/Divergence) is a trend following momentum indicator that shows the relationship between two moving averages of prices.
/// </summary>
[Description("MACD + MACD ZeroLag parametrées à la Johnlee.")]
public class MACDJL : Indicator
{
#region Variables
private int fast = 9;
private int slow = 19;
private int smooth = 6;
private double coeffBoll= 1.4;
private DataSeries fastEma;
private DataSeries slowEma;
private DataSeries fastEmaZL;
private DataSeries slowEmaZL;
private DataSeries smoothEmaZL;
private DataSeries ddsmoothEmaZL;
// Pour les bollinger Min
DataSeries minUp;
DataSeries minDown;
// Pour les zones à dessiner
private int beginUp=-1;
private int beginDown=-1;
private int beginUpZL=-1;
private int beginDownZL=-1;
private int[] suite;
private int isOut=0;
private const int MAXOUT=40;

#endregion

/// <summary>
/// This method is used to configure the indicator and is called once before any bar data is loaded.
/// </summary>
protected override void Initialize()
{
Add(new Plot(Color.MidnightBlue,PlotStyle.Dot, "MACD"));
Add(new Plot(Color.DarkViolet, "Avg"));

Add(new Plot(Color.LightSkyBlue, "MACDZL"));
Add(new Plot(Color.Orange, "AvgZL"));

Add(new Line(Color.DarkGray, 0, "Zero line"));

fastEma = new DataSeries(this);
slowEma = new DataSeries(this);
fastEmaZL = new DataSeries(this);
slowEmaZL = new DataSeries(this);
smoothEmaZL = new DataSeries(this);
ddsmoothEmaZL = new DataSeries(this);
minDown = new DataSeries(this);
minUp = new DataSeries(this);
suite = new int[MAXOUT];
DrawOnPricePanel = false;
CalculateOnBarClose = true;
PriceTypeSupported = true;
PaintPriceMarkers = false;
}
protected void DrawBollingers(string name,IDataSeries data,double numStdDev,
int period,int periodMAX,Color c,int opacity){

if(CurrentBar==0){
minUp.Set(0);
minDown.Set(0);
return;
}
if(periodMAX == 0 ) {
DrawRegion("Boll"+name,CurrentBar,0,Bollinger(data,numStdDev,period).Upper,
Bollinger(data,numStdDev,period).Lower,Color.Transparent,c,opacity);
} else {
double currSMA=SMA(data,period)[0];
double currMIN=MIN(StdDev(data,period),periodMAX)[0];
minUp.Set(currSMA+numStdDev*currMIN);
minDown.Set(currSMA-numStdDev*currMIN);
DrawRegion("UpVolat"+name,CurrentBar,0,minUp,Bollinger(data,numStdDev,period).Upper,Color.Gray,c,opacity);
DrawRegion("VolatBe"+name,CurrentBar,0,minUp,minDown,Color.Empty,c,1);
DrawRegion("DownVolat"+name,CurrentBar,0,minDown,Bollinger(data,numStdDev,period).Lower,Color.Gray,c,opacity);
}
}
/// <summary>
/// Calculates the indicator value(s) at the current index.
/// </summary>
protected override void OnBarUpdate()
{
if (CurrentBar == 0)
{
fastEma.Set(Input[0]);
slowEma.Set(Input[0]);
fastEmaZL.Set(Input[0]);
slowEmaZL.Set(Input[0]);
smoothEmaZL.Set(Input[0]);
ddsmoothEmaZL.Set(Input[0]);
MACD.Set(0);
Avg.Set(0);
MACDZL.Set(0);
AvgZL.Set(0);
}
else
{

double cMACDJL;
double cMACDJLAvg;
int summitBar;

// Le code est optimisé pour éviter des recalculs des EMA et DEMA

// Calcul de la MACD
fastEma.Set((2.0 / (1 + Fast)) * Input[0] + (1 - (2.0 / (1 + Fast))) * fastEma[1]);
slowEma.Set((2.0 / (1 + Slow)) * Input[0] + (1 - (2.0 / (1 + Slow))) * slowEma[1]);

cMACDJL = fastEma[0] - slowEma[0];
cMACDJLAvg = (2.0 / (1 + Smooth)) * cMACDJL + (1 - (2.0 / (1 + Smooth))) * Avg[1];

MACD.Set(cMACDJL);
Avg.Set(cMACDJLAvg);

// On recopie l'ancien sommet
if(cMACDJL < cMACDJLAvg ) {
beginUp=-1;
if(beginDown==-1){
beginDown=CurrentBar;
}
DrawRegion("MACDJL"+beginDown,Math.Min(CurrentBar-beginDown+1,CurrentBar),0,Avg,MACD,Color.Empty,Color.Red,1);

} else {
beginDown=-1;
if(beginUp==-1){
beginUp=CurrentBar;
}
DrawRegion("MACDJL"+beginUp,Math.Min(CurrentBar-beginUp+1,CurrentBar),0,Avg,MACD,Color.Empty,Color.Green,1);
}
DrawBollingers("MACDJL",MACD,coeffBoll,20,0,Color.LightGray,8);

// Calcul de la MACDZL
fastEmaZL.Set((2.0 / (1 + Fast)) * fastEma[0] + (1 - (2.0 / (1 + Fast))) * fastEmaZL[1]);
slowEmaZL.Set((2.0 / (1 + Slow)) * slowEma[0] + (1 - (2.0 / (1 + Slow))) * slowEmaZL[1]);

cMACDJL = (2*fastEma[0]-fastEmaZL[0]) - (2*slowEma[0]-slowEmaZL[0]);
smoothEmaZL.Set((2.0 / (1 + Smooth)) * cMACDJL + (1 - (2.0 / (1 + Smooth))) * smoothEmaZL[1]);
ddsmoothEmaZL.Set((2.0 / (1 + Smooth)) * smoothEmaZL[0] + (1 - (2.0 / (1 + Smooth))) * ddsmoothEmaZL[1]);

MACDZL.Set(cMACDJL);
cMACDJLAvg=2*smoothEmaZL[0]-ddsmoothEmaZL[0];
AvgZL.Set(cMACDJLAvg);

if(cMACDJL < cMACDJLAvg ) {
beginUpZL=-1;
if(beginDownZL==-1){
beginDownZL=CurrentBar;
}
DrawRegion("MACDJLZL"+beginDownZL,Math.Min(CurrentBar-beginDownZL+1,CurrentBar),0,AvgZL,MACDZL,Color.Empty,Color.Salmon,1);
} else {
beginDownZL=-1;
if(beginUpZL==-1){
beginUpZL=CurrentBar;
}
DrawRegion("MACDJLZL"+beginUpZL,Math.Min(CurrentBar-beginUpZL+1,CurrentBar),0,AvgZL,MACDZL,Color.Empty,Color.PaleGreen,1);
}

}
}

#region Properties
/// <summary>
/// </summary>
[Browsable(false)]
[XmlIgnore()]
public DataSeries MACD
{
get { return Values[0]; }
}

/// <summary>
/// </summary>

[Browsable(false)]
[XmlIgnore()]
public DataSeries Avg
{
get { return Values[1]; }
}

/// <summary>
/// </summary>
[Browsable(false)]
[XmlIgnore()]
public DataSeries MACDZL
{
get { return Values[2]; }
}
public DataSeries AvgZL
{
get { return Values[3]; }
}
/// <summary>
/// </summary>
[Description("Number of bars for fast EMA")]
[Category("Parameters")]
public int Fast
{
get { return fast; }
set { fast = Math.Max(1, value); }
}

/// <summary>
/// </summary>
[Description("Number of bars for slow EMA")]
[Category("Parameters")]
public int Slow
{
get { return slow; }
set { slow = Math.Max(1, value); }
}

/// <summary>
/// </summary>
[Description("Number of bars for smoothing")]
[Category("Parameters")]
public int Smooth
{
get { return smooth; }
set { smooth = Math.Max(1, value); }
}
[Description("MACD Bollinger coefficient")]
[Category("Parameters")]
public double CoeffBoll
{
get { return coeffBoll; }
set { coeffBoll = Math.Max(0.1, value); }
}
#endregion
}
}

#region NinjaScript generated code. Neither change nor remove.
// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
public partial class Indicator : IndicatorBase
{
private MACDJL[] cacheMACDJL = null;

private static MACDJL checkMACDJL = new MACDJL();

/// <summary>
/// MACD + MACD ZeroLag parametrées à la Johnlee.
/// </summary>
/// <returns></returns>
public MACDJL MACDJL(double coeffBoll, int fast, int slow, int smooth)
{
return MACDJL(Input, coeffBoll, fast, slow, smooth);
}

/// <summary>
/// MACD + MACD ZeroLag parametrées à la Johnlee.
/// </summary>
/// <returns></returns>
public MACDJL MACDJL(Data.IDataSeries input, double coeffBoll, int fast, int slow, int smooth)
{
checkMACDJL.CoeffBoll = coeffBoll;
coeffBoll = checkMACDJL.CoeffBoll;
checkMACDJL.Fast = fast;
fast = checkMACDJL.Fast;
checkMACDJL.Slow = slow;
slow = checkMACDJL.Slow;
checkMACDJL.Smooth = smooth;
smooth = checkMACDJL.Smooth;

if (cacheMACDJL != null)
for (int idx = 0; idx < cacheMACDJL.Length; idx++)
if (Math.Abs(cacheMACDJL[idx].CoeffBoll - coeffBoll) <= double.Epsilon && cacheMACDJL[idx].Fast == fast && cacheMACDJL[idx].Slow == slow && cacheMACDJL[idx].Smooth == smooth && cacheMACDJL[idx].EqualsInput(input))
return cacheMACDJL[idx];

MACDJL indicator = new MACDJL();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
indicator.Input = input;
indicator.CoeffBoll = coeffBoll;
indicator.Fast = fast;
indicator.Slow = slow;
indicator.Smooth = smooth;
indicator.SetUp();

MACDJL[] tmp = new MACDJL[cacheMACDJL == null ? 1 : cacheMACDJL.Length + 1];
if (cacheMACDJL != null)
cacheMACDJL.CopyTo(tmp, 0);
tmp[tmp.Length - 1] = indicator;
cacheMACDJL = tmp;
Indicators.Add(indicator);

return indicator;
}

}
}

// This namespace holds all market analyzer column definitions and is required. Do not change it.
namespace NinjaTrader.MarketAnalyzer
{
public partial class Column : ColumnBase
{
/// <summary>
/// MACD + MACD ZeroLag parametrées à la Johnlee.
/// </summary>
/// <returns></returns>
[Gui.Design.WizardCondition("Indicator")]
public Indicator.MACDJL MACDJL(double coeffBoll, int fast, int slow, int smooth)
{
return _indicator.MACDJL(Input, coeffBoll, fast, slow, smooth);
}

/// <summary>
/// MACD + MACD ZeroLag parametrées à la Johnlee.
/// </summary>
/// <returns></returns>
public Indicator.MACDJL MACDJL(Data.IDataSeries input, double coeffBoll, int fast, int slow, int smooth)
{
return _indicator.MACDJL(input, coeffBoll, fast, slow, smooth);
}

}
}

// This namespace holds all strategies and is required. Do not change it.
namespace NinjaTrader.Strategy
{
public partial class Strategy : StrategyBase
{
/// <summary>
/// MACD + MACD ZeroLag parametrées à la Johnlee.
/// </summary>
/// <returns></returns>
[Gui.Design.WizardCondition("Indicator")]
public Indicator.MACDJL MACDJL(double coeffBoll, int fast, int slow, int smooth)
{
return _indicator.MACDJL(Input, coeffBoll, fast, slow, smooth);
}

/// <summary>
/// MACD + MACD ZeroLag parametrées à la Johnlee.
/// </summary>
/// <returns></returns>
public Indicator.MACDJL MACDJL(Data.IDataSeries input, double coeffBoll, int fast, int slow, int smooth)
{
if (InInitialize && input == null)
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");

return _indicator.MACDJL(input, coeffBoll, fast, slow, smooth);
}

}
}
#endregion
</font>

**Jean-Phi** · 07/01/2010, 09:16

SqueezMACD

<font color='#056001'>#region Using declarations
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Xml.Serialization;
using NinjaTrader.Cbi;
using NinjaTrader.Data;
using NinjaTrader.Gui.Chart;
#endregion

// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
/// <summary>
/// Donne les Squeez MACD
/// </summary>
[Description("Donne les Squeez MACD")]
public class SqueezMACD : Indicator
{
#region Variables
// Wizard generated variables
private int fast = 9;
private int slow = 19;
private int smooth = 6;
private double coeffBoll = 1.400; // Default setting for CoeffBoll
private int periodMAX = 70; // Default setting for PeriodMAX
private double pcSqueez = 0.300; // Default setting for pcSqueez
// User defined variables (add any user defined variables below)
private DataSeries fastEma;
private DataSeries slowEma;
private DataSeries MACD;
private DataSeries stdDevMACD;
private DataSeries SqueezUp;
private DataSeries SqueezDown;
private int beginSq=0;
private int beginAcc=0;
#endregion

/// <summary>
/// This method is used to configure the indicator and is called once before any bar data is loaded.
/// </summary>
protected override void Initialize()
{
Add(new Plot(Color.FromKnownColor(KnownColor.Green), PlotStyle.Bar, "AccelerationUp"));
Plots[0].Pen.Width =3;
Add(new Plot(Color.FromKnownColor(KnownColor.Red), PlotStyle.Bar, "AccelerationDown"));
Plots[1].Pen.Width =3;
Add(new Plot(Color.FromKnownColor(KnownColor.DarkViolet), PlotStyle.Bar, "SortieUp"));
Add(new Plot(Color.FromKnownColor(KnownColor.Firebrick), PlotStyle.Bar, "SortieDown"));
Add(new Plot(Color.FromKnownColor(KnownColor.LightGray), PlotStyle.Line, "DelimUp"));
Add(new Plot(Color.FromKnownColor(KnownColor.LightGray), PlotStyle.Line, "DelimDown"));
Add(new Plot(Color.FromKnownColor(KnownColor.Black), PlotStyle.Line, "Phase"));
Add(new Line(Color.DarkGray, 0, "Zero line"));
fastEma = new DataSeries(this);
slowEma = new DataSeries(this);
MACD = new DataSeries(this);
stdDevMACD = new DataSeries(this);
SqueezUp = new DataSeries(this);
SqueezDown = new DataSeries(this);

DrawOnPricePanel = false;
CalculateOnBarClose = false;
Overlay = false;
PriceTypeSupported = true;

}

/// <summary>
/// Called on each bar update event (incoming tick)
/// </summary>
protected override void OnBarUpdate()
{
// Use this method for calculating your indicator values. Assign a value to each
// plot below by replacing 'Close[0]' with your own formula.
DelimUp.Set(4);
DelimDown.Set(-4);
if (CurrentBar == 0) {
fastEma.Set(Input[0]);
slowEma.Set(Input[0]);
MACD.Set(0);
stdDevMACD.Set(1);
AccelerationUp.Set(0);
AccelerationDown.Set(0);
SqueezUp.Set(0);
SqueezDown.Set(0);
Phase.Set(0);
return;
}

// Calcul de la MACD
fastEma.Set((2.0 / (1 + Fast)) * Input[0] + (1 - (2.0 / (1 + Fast))) * fastEma[1]);
slowEma.Set((2.0 / (1 + Slow)) * Input[0] + (1 - (2.0 / (1 + Slow))) * slowEma[1]);
MACD.Set(fastEma[0] - slowEma[0]);
stdDevMACD.Set(StdDev(MACD,20)[0]);
/*if ( CurrentBar <= 100 ) {
Print(CurrentBar+" sM : "+stdDevMACD[0].ToString("F2")+" mM: "+(MIN(stdDevMACD,periodMAX)[0]*(1.0+pcSqueez)).ToString("F2"));
}*/
if(stdDevMACD[0] <= MIN(stdDevMACD,periodMAX)[0]*(1.0+pcSqueez)) {
//Print(CurrentBar+" bsQ : "+beginSq);
if(beginSq == 0 ) {
// On colorie toute la zone
beginSq = CurrentBar;
}
SqueezUp.Set(2);
SqueezDown.Set(-2);
DrawRegion("SqMACD"+beginSq,CurrentBar-beginSq+1,0,SqueezUp,SqueezDown,Color.Empty,Color.LightGray,6);
} else {
if(beginSq != 0 ) {
DrawRegion("SqMACD"+beginSq,CurrentBar-beginSq+1,0,SqueezUp,SqueezDown,Color.Empty,Color.LightGray,6);
}
beginSq = 0;
}
if ( MACD[0] >= SMA(MACD,20)[0] + 1.4*stdDevMACD[0] ) {
AccelerationUp.Set(2.5);
} else if ( MACD[0] <= SMA(MACD,20)[0] - 1.4*stdDevMACD[0] ) {
AccelerationDown.Set(-2.5);
}
for(int x=Math.Min(CurrentBar,5);x>=0;x--) {

}
SortieUp.Set(0);
SortieDown.Set(0);
}

#region Properties
[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries AccelerationUp
{
get { return Values[0]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries AccelerationDown
{
get { return Values[1]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries SortieUp
{
get { return Values[2]; }
}

[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries SortieDown
{
get { return Values[3]; }
}
[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries DelimUp
{
get { return Values[4]; }
}
[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries DelimDown
{
get { return Values[5]; }
}
[Browsable(false)] // this line prevents the data series from being displayed in the indicator properties dialog, do not remove
[XmlIgnore()] // this line ensures that the indicator can be saved/recovered as part of a chart template, do not remove
public DataSeries Phase
{
get { return Values[6]; }
}
[Description("Number of bars for fast EMA")]
[Category("Parameters")]
public int Fast
{
get { return fast; }
set { fast = Math.Max(1, value); }
}

/// <summary>
/// </summary>
[Description("Number of bars for slow EMA")]
[Category("Parameters")]
public int Slow
{
get { return slow; }
set { slow = Math.Max(1, value); }
}

/// <summary>
/// </summary>
[Description("Number of bars for smoothing")]
[Category("Parameters")]
public int Smooth
{
get { return smooth; }
set { smooth = Math.Max(1, value); }
}
[Description("Coefficient des Bollingers")]
[Category("Parameters")]
public double CoeffBoll
{
get { return coeffBoll; }
set { coeffBoll = Math.Max(0.100, value); }
}

[Description("Nombre de période maximum")]
[Category("Parameters")]
public int PeriodMAX
{
get { return periodMAX; }
set { periodMAX = Math.Max(1, value); }
}

[Description("Pourcentage détection squeez")]
[Category("Parameters")]
public double PcSqueez
{
get { return pcSqueez; }
set { pcSqueez = Math.Max(0.00, value); }
}
#endregion
}
}

#region NinjaScript generated code. Neither change nor remove.
// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
public partial class Indicator : IndicatorBase
{
private SqueezMACD[] cacheSqueezMACD = null;

private static SqueezMACD checkSqueezMACD = new SqueezMACD();

/// <summary>
/// Donne les Squeez MACD
/// </summary>
/// <returns></returns>
public SqueezMACD SqueezMACD(double coeffBoll, int fast, double pcSqueez, int periodMAX, int slow, int smooth)
{
return SqueezMACD(Input, coeffBoll, fast, pcSqueez, periodMAX, slow, smooth);
}

/// <summary>
/// Donne les Squeez MACD
/// </summary>
/// <returns></returns>
public SqueezMACD SqueezMACD(Data.IDataSeries input, double coeffBoll, int fast, double pcSqueez, int periodMAX, int slow, int smooth)
{
checkSqueezMACD.CoeffBoll = coeffBoll;
coeffBoll = checkSqueezMACD.CoeffBoll;
checkSqueezMACD.Fast = fast;
fast = checkSqueezMACD.Fast;
checkSqueezMACD.PcSqueez = pcSqueez;
pcSqueez = checkSqueezMACD.PcSqueez;
checkSqueezMACD.PeriodMAX = periodMAX;
periodMAX = checkSqueezMACD.PeriodMAX;
checkSqueezMACD.Slow = slow;
slow = checkSqueezMACD.Slow;
checkSqueezMACD.Smooth = smooth;
smooth = checkSqueezMACD.Smooth;

if (cacheSqueezMACD != null)
for (int idx = 0; idx < cacheSqueezMACD.Length; idx++)
if (Math.Abs(cacheSqueezMACD[idx].CoeffBoll - coeffBoll) <= double.Epsilon && cacheSqueezMACD[idx].Fast == fast && Math.Abs(cacheSqueezMACD[idx].PcSqueez - pcSqueez) <= double.Epsilon && cacheSqueezMACD[idx].PeriodMAX == periodMAX && cacheSqueezMACD[idx].Slow == slow && cacheSqueezMACD[idx].Smooth == smooth && cacheSqueezMACD[idx].EqualsInput(input))
return cacheSqueezMACD[idx];

SqueezMACD indicator = new SqueezMACD();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
indicator.Input = input;
indicator.CoeffBoll = coeffBoll;
indicator.Fast = fast;
indicator.PcSqueez = pcSqueez;
indicator.PeriodMAX = periodMAX;
indicator.Slow = slow;
indicator.Smooth = smooth;
indicator.SetUp();

SqueezMACD[] tmp = new SqueezMACD[cacheSqueezMACD == null ? 1 : cacheSqueezMACD.Length + 1];
if (cacheSqueezMACD != null)
cacheSqueezMACD.CopyTo(tmp, 0);
tmp[tmp.Length - 1] = indicator;
cacheSqueezMACD = tmp;
Indicators.Add(indicator);

return indicator;
}

}
}

// This namespace holds all market analyzer column definitions and is required. Do not change it.
namespace NinjaTrader.MarketAnalyzer
{
public partial class Column : ColumnBase
{
/// <summary>
/// Donne les Squeez MACD
/// </summary>
/// <returns></returns>
[Gui.Design.WizardCondition("Indicator")]
public Indicator.SqueezMACD SqueezMACD(double coeffBoll, int fast, double pcSqueez, int periodMAX, int slow, int smooth)
{
return _indicator.SqueezMACD(Input, coeffBoll, fast, pcSqueez, periodMAX, slow, smooth);
}

/// <summary>
/// Donne les Squeez MACD
/// </summary>
/// <returns></returns>
public Indicator.SqueezMACD SqueezMACD(Data.IDataSeries input, double coeffBoll, int fast, double pcSqueez, int periodMAX, int slow, int smooth)
{
return _indicator.SqueezMACD(input, coeffBoll, fast, pcSqueez, periodMAX, slow, smooth);
}

}
}

// This namespace holds all strategies and is required. Do not change it.
namespace NinjaTrader.Strategy
{
public partial class Strategy : StrategyBase
{
/// <summary>
/// Donne les Squeez MACD
/// </summary>
/// <returns></returns>
[Gui.Design.WizardCondition("Indicator")]
public Indicator.SqueezMACD SqueezMACD(double coeffBoll, int fast, double pcSqueez, int periodMAX, int slow, int smooth)
{
return _indicator.SqueezMACD(Input, coeffBoll, fast, pcSqueez, periodMAX, slow, smooth);
}

/// <summary>
/// Donne les Squeez MACD
/// </summary>
/// <returns></returns>
public Indicator.SqueezMACD SqueezMACD(Data.IDataSeries input, double coeffBoll, int fast, double pcSqueez, int periodMAX, int slow, int smooth)
{
if (InInitialize && input == null)
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");

return _indicator.SqueezMACD(input, coeffBoll, fast, pcSqueez, periodMAX, slow, smooth);
}

}
}
#endregion</font>

**Univers Bourse** · 28/05/2013, 16:34

Discussion déplacée dans notre nouveau forum Ninja Trader

**La Verole** · 19/07/2013, 17:40

Bonjour

Dans la pagaille du forum NinjaTrader je post ici.....

Besoin d'aide pour importation de code .
Pas mal de codes donnés ci-dessus mais comment les importer.
Pas aussi simple que PRT,le copier coller ne fonctionne pas .....

Exemple: j'ai un code STPMT

//----------------------------------------------------------------------------------------------------
// STPMT
//----------------------------------------------------------------------------------------------------
inputs:
Length(9) ;

variables:
STPMT(0),
MM_STPMT(0),STOCH1(0),STOCH2(0),STOCH3(0),STOCH4(0 );

STPMT = (4.1*SlowKCustomOrig(H, L, C, 5, 3) + 2.5*SlowKCustomOrig(H, L, C, 14, 3)
+ SlowKCustomOrig(h, L, C, 45, 14) + 4*SlowKCustomOrig(H, L, C, 75, 20))/11.6;
MM_STPMT = Average(STPMT, Length);
STOCH1=SlowKCustomOrig(H, L, C, 5, 3);
STOCH2=SlowKCustomOrig(H, L, C, 14, 3);
STOCH3=SlowKCustomOrig(H, L, C, 45, 14);
STOCH4=SlowKCustomOrig(H, L, C, 75, 20);

Plot1( STPMT, "STPMT" ) ;
Plot2( MM_STPMT, "MM_STPMT" ) ;
//Plot3( STOCH1, "STOCH1" ) ;
//Plot3( STOCH2, "STOCH2" ) ;
//Plot3( STOCH3, "STOCH3" ) ;
//Plot3( STOCH4, "STOCH4" ) ;

Tools=>New NinjaScript =>indicator

A partir de la fenêtre n°2 je ne remplie rien et je clique sur finish.
Apparait une fenêtre ou je vire tout et y colle le code STPMT , je compile et rien !!!!!

Rien trouvé sur le NET sur ce problème précis ....

**raptor90** · 19/07/2013, 18:33

j'ai pas nt mais j'ai un peu pratiqué sur mt4

après avoir compilé tu n'as pas "rien" mais une erreur
avec une case "click for more info"

un problème d'espace mais ça s'arrête à "con"

il faut corriger cette erreur pour réussir la compile et que l'indic soit intégré à la plateforme

**La Verole** · 19/07/2013, 19:05

Merci à vous deux .
Vous avez toujours réponse à tous .
J'ai fait un beau tuto ça pourra tour servir .
Pour info le code je l'ai chourrer à Chipeur mais je ne retrouve plus mon lien.......

Merci les garçons je vais étudier ça ce Week-end au frais .....

**chipeur** · 20/07/2013, 16:41

Envoyé par La Verole Voir le message

Merci à vous deux .
Vous avez toujours réponse à tous .
J'ai fait un beau tuto ça pourra tour servir .
Pour info le code je l'ai chourrer à Chipeur mais je ne retrouve plus mon lien.......

Merci les garçons je vais étudier ça ce Week-end au frais .....

**La Verole** · 20/07/2013, 22:03

http://forums.univers-bourse.com/indicateurs-et-syst%E8mes/12234-indicateurs-eric-pour-multicharts.html

**La Verole** · 21/07/2013, 18:15

Bon petit à petit l'oiseau fait son nid

Un solution pour virer ce parasitage sur graph
J'ai tout bidouillé dans "indicateur" ou dans "Chart Properties" ça colle au graph

**La Verole** · 21/07/2013, 22:19

Absolument génial !!!!!!!

Je commence à en pincer grave

Merci Arnaud

CODES NINJA TRADER

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire