Jump to content

Welcome to the new Traders Laboratory! Please bear with us as we finish the migration over the next few days. If you find any issues, want to leave feedback, get in touch with us, or offer suggestions please post to the Support forum here.

  • Welcome Guests

    Welcome. You are currently viewing the forum as a guest which does not give you access to all the great features at Traders Laboratory such as interacting with members, access to all forums, downloading attachments, and eligibility to win free giveaways. Registration is fast, simple and absolutely free. Create a FREE Traders Laboratory account here.

thehaul

TTM Scalp Average for Ninja

Recommended Posts

Looking for some help on an average based off of the TTM scalp easy language code. Most of it has been successfully translated but I'm need some tweak help. Attached is the zipped file and screen shot. I would like to reduce the times the paint bar fires. It seems redundant to me. So, adding a "no plot if a swing hi/ swing low fired 2 bars ago" kind of scenario. I also would like to be able to turn the paint bar off as well. I have little knowledge of coding for ninja and need some guidance. If anyone wants to offer it up here in this thread so others can learn great, but if someone would rather get paid for the tweak I am up for that as well. Thx

5aa70ea87cd34_Screencapture1.thumb.png.8d771ed5b26e6a2a5614e2926d2abe75.png

SeansAveragev3.zip

Share this post


Link to post
Share on other sites

Its basically an average of swing hi/lo. That's it. There's a round to the nearest tick function added and I like to use it with the square parameter to get the step looking line. I feel the ES likes to revisit certain areas and depending on market thrust it tends to retrace back to this average. I like the way the code acts but would like to limit the number of times it fires. Does this help??

Share this post


Link to post
Share on other sites

A couple of things. The code does not use ttm scalper code to define swing highs and lows. It uses Ninja's built in Swing indicator which is not the same thing. The square line is also not just a simple average of the swings as there are points in between which I can't figure out. Some more details would be nice. The code seems to be averaging using a user length on a series called midpoints. Midpoints of swing high and lows is straightforward, but what is used in between? if I had more patience I would decipher the code but I'd rather know a description of that line from you and see what I can do from there.

Share this post


Link to post
Share on other sites

Here's the code to look at... for anybody to look at...

 

 

//

// Copyright © 2008, SBG Trading Corp. http://www.affordableindicators.com

// Use this indicator/strategy at your own risk. No warranty expressed or implied.

// Trading financial instruments is risky and can result in substantial loss.

// The owner of this indicator/strategy holds harmless SBG Trading Corp. from any

// and all trading losses incurred while using this indicator/strategy.

//

//

 

 

#region Using declarations

using System;

using System.Diagnostics;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.ComponentModel;

using System.Xml.Serialization;

//using NinjaTrader.Cbi;

using NinjaTrader.Data;

using NinjaTrader.Gui.Chart;

#endregion

 

namespace NinjaTrader.Indicator

{

/// <summary>

///

/// </summary>

[Description("Translated from TradeStation")]

[Gui.Design.DisplayName("Seans Average")]

public class SeansAverage_v3 : Indicator

{

#region Variables

private const int _UP = 1;

private const int _DOWN = -1;

// Wizard generated variables

private int pLen=4;

private bool pRoundToTick = false;

private Color pSwingBarColor = Color.White;

 

private DataSeries Midpoints;

private int highBarsAgo=1;

private int possibleHighBarsAgo = 1;

private double possibleHigh = double.MinValue;

private double hightoBeat = double.MinValue+1;

private int barsSincePaint = 1;

private int lowBarsAgo = 1;

private int possibleLowBarsAgo = 1;

private double possibleLow = double.MaxValue;

private double lowtoBeat = double.MaxValue-1;

private double triggerPriceSell = double.MinValue+1;

private double triggerPriceBuy = double.MaxValue-1;

private double theavg=double.MinValue;

private int trend = _UP;

private double s_low = 1;

private double s_high = 1;

private bool RunInit = true;

#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.Gold,1), PlotStyle.Line, "SeansAvg"));

CalculateOnBarClose = true;

Overlay = true;

PriceTypeSupported = false;

Midpoints = new DataSeries (this);

}

 

/// <summary>

/// Called on each bar update event (incoming tick)

/// </summary>

protected override void OnBarUpdate()

{

if(RunInit) {

s_low=Low[0];

s_high=High[0];

RunInit=false;

}

int b=0;

 

if(CurrentBar<highBarsAgo || CurrentBar<lowBarsAgo) return;

//***************************************************

//****** Find and plot the highest swing high *******

//***************************************************

if (trend == _UP) {

b = Swing(1).SwingHighBar(0, 1, barsSincePaint+2);

if (b > -1) {

possibleHighBarsAgo = b;

possibleHigh = High[possibleHighBarsAgo];

}

 

if (possibleHigh >= hightoBeat) {

highBarsAgo = possibleHighBarsAgo;

hightoBeat = possibleHigh;

triggerPriceSell = Low[highBarsAgo - 1];

}

 

double temp=High[0];

for(int i=1;i<highBarsAgo;i++)//this calculates the highest high since

temp = Math.Max(temp,High);

 

if (Close[0] < triggerPriceSell || temp < hightoBeat) {

if(pSwingBarColor != Color.Transparent) {

DrawLine("bar"+(CurrentBar-highBarsAgo),highBarsAgo,High[highBarsAgo],highBarsAgo,Low[highBarsAgo],pSwingBarColor,DashStyle.Solid,ChartControl.BarWidth+2);

// BarColor = pSwingBarColor;

// CandleOutlineColor = ChartControl.BarOutlinePen.Color;

}

trend = _DOWN;

barsSincePaint = highBarsAgo-1;

hightoBeat = double.MinValue+1;

lowtoBeat = double.MaxValue-1;

triggerPriceBuy = double.MaxValue-1;

triggerPriceSell = double.MinValue;

possibleHigh = double.MinValue;

highBarsAgo = 1;

s_high = Low[0];

}

}

 

// //***************************************************

// //****** Find and plot the lowest swing low *********

// //***************************************************

 

if (trend == _DOWN) {

b = Swing(1).SwingLowBar(0, 1, barsSincePaint+2);

if (b > -1) {

possibleLowBarsAgo = b;

possibleLow = Low[possibleLowBarsAgo];

}

 

if (possibleLow <= lowtoBeat) {

lowBarsAgo = possibleLowBarsAgo;

lowtoBeat = possibleLow;

triggerPriceBuy = High[lowBarsAgo - 1];

}

 

double temp=Low[0];

for(int i=1;i<lowBarsAgo;i++) //this calculates the lowest low since lowBarsAgo

temp = Math.Min(temp,Low);

 

if (Close[0] > triggerPriceBuy || temp > lowtoBeat) {

if(pSwingBarColor != Color.Transparent) {

DrawLine("bar"+(CurrentBar-lowBarsAgo),lowBarsAgo,High[lowBarsAgo],lowBarsAgo,Low[lowBarsAgo],pSwingBarColor,DashStyle.Solid,ChartControl.BarWidth+2);

// BarColor = pSwingBarColor;

// CandleOutlineColor = ChartControl.BarOutlinePen.Color;

}

trend = _UP;

barsSincePaint = lowBarsAgo-1;

lowtoBeat = double.MaxValue-1;

hightoBeat = double.MinValue+1;

triggerPriceBuy = double.MaxValue-1;

triggerPriceSell = double.MinValue+1;

possibleLow = double.MaxValue;

lowBarsAgo = 1;

s_low = High[0];

}

}

 

 

Midpoints.Set((s_low + s_high)/2.0);

theavg = SMA(Midpoints, pLen)[0];

 

if(pRoundToTick) theavg = NormalizePrice(theavg);

Avg.Set(theavg);

 

barsSincePaint = barsSincePaint+1;

if (trend == _UP) highBarsAgo = highBarsAgo + 1;

if (trend == _DOWN) lowBarsAgo = lowBarsAgo + 1;

}

//=================================================================

private double NormalizePrice(double ThePrice)

{

int Temp = (int) Math.Round(ThePrice / TickSize);

return ((double) Temp * TickSize);

}

//=================================================================

 

#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 Avg

{

get { return Values[0]; }

}

 

[Description("Round to nearest tick?")]

[Category("Parameters")]

public bool RoundToTick

{

get { return pRoundToTick; }

set { pRoundToTick = value; }

}

[Description("Period")]

[Category("Parameters")]

public int Period

{

get { return pLen; }

set { pLen = Math.Max(1, value); }

}

[XmlIgnore()]

[Description("Color of swing pivot bar (set to 'Transparent' to disengage coloring)")]

[Category("Visual")]

public Color SwingBarColor{ get { return pSwingBarColor; } set { pSwingBarColor = value; } }

[browsable(false)]

public string ClSerialize

{ get { return NinjaTrader.Gui.Design.SerializableColor.ToString(pSwingBarColor); } set { pSwingBarColor = NinjaTrader.Gui.Design.SerializableColor.FromString(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 SeansAverage_v3[] cacheSeansAverage_v3 = null;

 

private static SeansAverage_v3 checkSeansAverage_v3 = new SeansAverage_v3();

 

/// <summary>

/// Translated from TradeStation

/// </summary>

/// <returns></returns>

public SeansAverage_v3 SeansAverage_v3(int period, bool roundToTick)

{

return SeansAverage_v3(Input, period, roundToTick);

}

 

/// <summary>

/// Translated from TradeStation

/// </summary>

/// <returns></returns>

public SeansAverage_v3 SeansAverage_v3(Data.IDataSeries input, int period, bool roundToTick)

{

checkSeansAverage_v3.Period = period;

period = checkSeansAverage_v3.Period;

checkSeansAverage_v3.RoundToTick = roundToTick;

roundToTick = checkSeansAverage_v3.RoundToTick;

 

if (cacheSeansAverage_v3 != null)

for (int idx = 0; idx < cacheSeansAverage_v3.Length; idx++)

if (cacheSeansAverage_v3[idx].Period == period && cacheSeansAverage_v3[idx].RoundToTick == roundToTick && cacheSeansAverage_v3[idx].EqualsInput(input))

return cacheSeansAverage_v3[idx];

 

SeansAverage_v3 indicator = new SeansAverage_v3();

indicator.BarsRequired = BarsRequired;

indicator.CalculateOnBarClose = CalculateOnBarClose;

indicator.Input = input;

indicator.Period = period;

indicator.RoundToTick = roundToTick;

indicator.SetUp();

 

SeansAverage_v3[] tmp = new SeansAverage_v3[cacheSeansAverage_v3 == null ? 1 : cacheSeansAverage_v3.Length + 1];

if (cacheSeansAverage_v3 != null)

cacheSeansAverage_v3.CopyTo(tmp, 0);

tmp[tmp.Length - 1] = indicator;

cacheSeansAverage_v3 = 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>

/// Translated from TradeStation

/// </summary>

/// <returns></returns>

[Gui.Design.WizardCondition("Indicator")]

public Indicator.SeansAverage_v3 SeansAverage_v3(int period, bool roundToTick)

{

return _indicator.SeansAverage_v3(Input, period, roundToTick);

}

 

/// <summary>

/// Translated from TradeStation

/// </summary>

/// <returns></returns>

public Indicator.SeansAverage_v3 SeansAverage_v3(Data.IDataSeries input, int period, bool roundToTick)

{

return _indicator.SeansAverage_v3(input, period, roundToTick);

}

 

}

}

 

// This namespace holds all strategies and is required. Do not change it.

namespace NinjaTrader.Strategy

{

public partial class Strategy : StrategyBase

{

/// <summary>

/// Translated from TradeStation

/// </summary>

/// <returns></returns>

[Gui.Design.WizardCondition("Indicator")]

public Indicator.SeansAverage_v3 SeansAverage_v3(int period, bool roundToTick)

{

return _indicator.SeansAverage_v3(Input, period, roundToTick);

}

 

/// <summary>

/// Translated from TradeStation

/// </summary>

/// <returns></returns>

public Indicator.SeansAverage_v3 SeansAverage_v3(Data.IDataSeries input, int period, bool roundToTick)

{

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.SeansAverage_v3(input, period, roundToTick);

}

 

}

}

#endregion

Share this post


Link to post
Share on other sites

here's an image of actual scalper peaks and troughs. From that the midpoint is calculated and plotted (No smoothing is done). Changes in the midpoint are done at the time a peak/trough is detected. While scalper paints in the past based on the confriming bar, the midpoint paints at the time of the confirming bar. Does this look closer to what you had intended?

ScalperMid.thumb.png.8c0bdbfd79bc1bcab365818573516c60.png

Share this post


Link to post
Share on other sites

It does look more like it. But when I would add length to the original it wouldn't create any smoothing. In this screen capture it shows a cyan 4 length and a yellow 1 length.

5aa70ea948d0d_Screencapture6.thumb.png.05023943e4bce30d854324b2f781e399.png

Edited by thehaul

Share this post


Link to post
Share on other sites

Here's a good example. The cyan line is a 4 length and the yellow is a 11 length. In the box the scalper code fires a cyan bar, both averages make a step down when that cyan bar appears 2 bars later. Then a magenta bar fires and the average reacts a few bars later. But as you can see cyan line makes it back to price faster and the yellow becomes resistance. This is only one scenario but there's many possible. But as you can see the longer length line doesn't smooth like my new Ninja version.

5aa70ea958c4d_Screencapture2.thumb.png.2018d8d8b916e97914cbf39d160a1e5b.png

Share this post


Link to post
Share on other sites
Here's a good example. The cyan line is a 4 length and the yellow is a 11 length. In the box the scalper code fires a cyan bar, both averages make a step down when that cyan bar appears 2 bars later. Then a magenta bar fires and the average reacts a few bars later. But as you can see cyan line makes it back to price faster and the yellow becomes resistance. This is only one scenario but there's many possible. But as you can see the longer length line doesn't smooth like my new Ninja version.

 

 

I see. The image is much clearer. I can assume that the period is also being used in the swing function within Ninja, but I'll investigate.

Share this post


Link to post
Share on other sites

This is a 15127 volume chart so the Scalp fires less when there's a trend and fires more when it's cycling. You can see that in the average itself as the longer term average wiggles.

5aa70ea980832_Screencapture8.thumb.png.4dd564c4465e0bda7b1cefcb50af70b9.png

Share this post


Link to post
Share on other sites

maybe someone can chime in and clarify how this statement works in Tradestation:

 

theavg = average((( s_low + s_high) /2 ), len);

 

I would assume that average requires a series as input. So what happens when s_low + s_high) /2 is inserted instead? Is this truly equivalent to the following ninja statement:

 

Midpoints.Set((s_low + s_high)/2.0);

theavg = SMA(Midpoints, pLen)[0];

Share this post


Link to post
Share on other sites

The real question is how you code it so it doesn't smooth with length is added. I will make a video of how the average works within multicharts to see if that sheds some light. We know there's some questionable code in the EL version it just happens to do some good things and some things that can't be answered. This is not a good place for an indicator. Trading should be built around solid mechanics and the user should understand exactly what's going on. I think this is my process now and thankfully Justlurkin is helping me out. There's lots of disciplines in this game. It's all about the one you decide works for you. I've started on this path and want to see it to the end and if the end is a cliff I'm ready to move to the next peak!

Share this post


Link to post
Share on other sites

Jan 20, 2009 was a good day even for the Ninja version. It's crazy to me the volume spike didn't happen till the move was over. Maybe it's not crazy? Expected? The cyan arrow is the overnight low, I would think breaking that would of caused more selling volume. I guess everyone believed the Obama rally hype. I know I did when I first turned on the TV.

It obvious there's plenty of trades on this chart. I look at it as the longer average is over the shorter so I just look for shorts. There's a few here. You just have to figure out what plan to follow. I like crosses of the shorter average and not rejections but on the longer I like rejections and not crosses. If that makes any sense.

5aa70ea9ef6d1_Screencapture10.thumb.png.bc246048a509f046a8573b223bb94a88.png

Share this post


Link to post
Share on other sites

I think this makes more sense now. The previous code averaged all points between swing high/lows since it uses a dataseries. This means, that if there are 4 swing points across 100 bars, the midpoint series would be 100 bars wide and an average using, for example, a length of 4 would average the last 4 points and tack it on. However, it seems that you are looking for average of 4 midpoints only, regardless of the number of bars, making the actual dataseries of midpoints much shorter and out of sync with the bars series, an array or list perhaps. This would get you a flat line between swing paints. This probably sounds incoherent but I'll look into it, seems simple enough.

 

This implies that the following are not equivalent:

Tradestation:

theavg = average((( s_low + s_high) /2 ), len);

 

Ninja:

Midpoints.Set((s_low + s_high)/2.0);

theavg = SMA(Midpoints, pLen)[0];

 

The Tradestation version is adding to "theavg" only when a new swing is detected.

The Ninja version is adding a point on every bar, hence the extreme smoothing.

 

At least this is my assumption.

Edited by justlurkin

Share this post


Link to post
Share on other sites

Sounds like you're heading the right direction. I'm not sure how to code it but if the length is set to 4 then the average needs to have 4 points to take the average of the 4 before. So, as price moves on the line is static and plots a flat line based from the last calculation until it has the required 4 to make the next calculation.... i think

 

 

thx!

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.


×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.