The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

ajv said:
Michael,

Great work and thanks for sharing your resonance discovery. You might be aware that there is already a proven mathematical price change and time ratio which work for any markets. Your resonance ratio is very interesting and proves that elliott wave does exist.

Regards,
Anil
Click to expand...

Well, thank you for your kind words and refreshing open mind.

Cordially,
Michael Calhoun
Juris Doctorate
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

This thread is getting boring,call some trades and show us how good it is
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

This looks remarkably similar to the zig zag indicator in Ninja Trader.
Is this just a recompiled ninja indicator with red and green added
as trend strength identifier.
Modifying and re-compiling standard NT indicators is pretty easy really.

Works a treat in hindsight, lags too much to be of any use in real time.
Oh and the swing low / high is not concrete either.
If price moves lower, the indicator re-plots.
OK for previous levels at a glance, useless in real time due to excessive lag.
 

Attachments

  • Zig zag indicator in ninja.png
    Zig zag indicator in ninja.png
    80.6 KB · Views: 743
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

TheCycleCode said:
My partner and I, Julian Sebastian have been working on the cycle code for years. He has discovered most of the resonances in the S&P.
Click to expand...

So after years of developing it, you are now here to sell it I presume,
you do have a vendor badge...
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

Liquid validity said:
This looks remarkably similar to the zig zag indicator in Ninja Trader.
Is this just a recompiled ninja indicator with red and green added
as trend strength identifier.
Modifying and re-compiling standard NT indicators is pretty easy really.
Click to expand...

Here's the source code, easy to access, alter and re-compile:
Code: 
// 
// 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.Collections;
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

// This namespace holds all indicators and is required. Do not change it.
namespace NinjaTrader.Indicator
{
    /// <summary>
    /// The ZigZag indicator shows trend lines filtering out changes below a defined level. 
    /// </summary>
    [Description("The ZigZag indicator shows trend lines filtering out changes below a defined level. ")]
    public class ZigZag : Indicator
    {
        #region Variables
		private double			currentZigZagHigh	= 0;
		private double			currentZigZagLow	= 0;
		private DeviationType	deviationType		= DeviationType.Points;
		private double			deviationValue		= 0.5;
		private DataSeries		zigZagHighZigZags; 
		private DataSeries		zigZagLowZigZags; 
		private DataSeries		zigZagHighSeries; 
		private DataSeries		zigZagLowSeries; 
		private int				lastSwingIdx		= -1;
		private double			lastSwingPrice		= 0.0;
		private int				trendDir			= 0; // 1 = trend up, -1 = trend down, init = 0
		private bool			useHighLow			= false;

        #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.Blue, PlotStyle.Line, "ZigZag"));

			zigZagHighSeries	= new DataSeries(this, MaximumBarsLookBack.Infinite); 
			zigZagHighZigZags	= new DataSeries(this, MaximumBarsLookBack.Infinite); 
			zigZagLowSeries		= new DataSeries(this, MaximumBarsLookBack.Infinite); 
			zigZagLowZigZags	= new DataSeries(this, MaximumBarsLookBack.Infinite); 

			DisplayInDataBox	= false;
            Overlay				= true;
			PaintPriceMarkers	= false;
        }

		/// <summary>
		/// Returns the number of bars ago a zig zag low occurred. Returns a value of -1 if a zig zag low is not found within the look back period.
		/// </summary>
		/// <param name="barsAgo"></param>
		/// <param name="instance"></param>
		/// <param name="lookBackPeriod"></param>
		/// <returns></returns>
		public int LowBar(int barsAgo, int instance, int lookBackPeriod) 
		{
			if (instance < 1)
				throw new Exception(GetType().Name + ".LowBar: instance must be greater/equal 1 but was " + instance);
			else if (barsAgo < 0)
				throw new Exception(GetType().Name + ".LowBar: barsAgo must be greater/equal 0 but was " + barsAgo);
			else if (barsAgo >= Count)
				throw new Exception(GetType().Name + ".LowBar: barsAgo out of valid range 0 through " + (Count - 1) + ", was " + barsAgo + ".");

			Update();
			for (int idx = CurrentBar - barsAgo - 1; idx >= CurrentBar - barsAgo - 1 - lookBackPeriod; idx--)
			{
				if (idx < 0)
					return -1;
				if (idx >= zigZagLowZigZags.Count)
					continue;				

				if (zigZagLowZigZags.Get(idx).Equals(0.0))			
					continue;

				if (instance == 1) // 1-based, < to be save
					return CurrentBar - idx;	

				instance--;
			}
	
			return -1;
		}


		/// <summary>
		/// Returns the number of bars ago a zig zag high occurred. Returns a value of -1 if a zig zag high is not found within the look back period.
		/// </summary>
		/// <param name="barsAgo"></param>
		/// <param name="instance"></param>
		/// <param name="lookBackPeriod"></param>
		/// <returns></returns>
		public int HighBar(int barsAgo, int instance, int lookBackPeriod) 
		{
			if (instance < 1)
				throw new Exception(GetType().Name + ".HighBar: instance must be greater/equal 1 but was " + instance);
			else if (barsAgo < 0)
				throw new Exception(GetType().Name + ".HighBar: barsAgo must be greater/equal 0 but was " + barsAgo);
			else if (barsAgo >= Count)
				throw new Exception(GetType().Name + ".HighBar: barsAgo out of valid range 0 through " + (Count - 1) + ", was " + barsAgo + ".");

			Update();
			for (int idx = CurrentBar - barsAgo - 1; idx >= CurrentBar - barsAgo - 1 - lookBackPeriod; idx--)
			{
				if (idx < 0)
					return -1;
				if (idx >= zigZagHighZigZags.Count)
					continue;				

				if (zigZagHighZigZags.Get(idx).Equals(0.0))			
					continue;

				if (instance <= 1) // 1-based, < to be save
					return CurrentBar - idx;	

				instance--;
			}

			return -1;
		}

        /// <summary>
        /// Called on each bar update event (incoming tick)
        /// </summary>
        protected override void OnBarUpdate()
        {
			if (CurrentBar < 2) // need 3 bars to calculate Low/High
			{
				zigZagHighSeries.Set(0);
				zigZagHighZigZags.Set(0);
				zigZagLowSeries.Set(0);
				zigZagLowZigZags.Set(0);
				return;
			}

			// Initialization
			if (lastSwingPrice == 0.0)
				lastSwingPrice = Input[0];

			IDataSeries highSeries	= High;
			IDataSeries lowSeries	= Low;

			if (!useHighLow)
			{
				highSeries	= Input;
				lowSeries	= Input;
			}

			// Calculation always for 1-bar ago !

			double tickSize = Bars.Instrument.MasterInstrument.TickSize;
			bool isSwingHigh	= highSeries[1] >= highSeries[0] - double.Epsilon 
								&& highSeries[1] >= highSeries[2] - double.Epsilon;
			bool isSwingLow		= lowSeries[1] <= lowSeries[0] + double.Epsilon 
								&& lowSeries[1] <= lowSeries[2] + double.Epsilon;  
			bool isOverHighDeviation	= (deviationType == DeviationType.Percent && IsPriceGreater(highSeries[1], (lastSwingPrice * (1.0 + deviationValue * 0.01))))
										|| (deviationType == DeviationType.Points && IsPriceGreater(highSeries[1], lastSwingPrice + deviationValue));
			bool isOverLowDeviation		= (deviationType == DeviationType.Percent && IsPriceGreater(lastSwingPrice * (1.0 - deviationValue * 0.01), lowSeries[1]))
										|| (deviationType == DeviationType.Points && IsPriceGreater(lastSwingPrice - deviationValue, lowSeries[1]));

			double	saveValue	= 0.0;
			bool	addHigh		= false; 
			bool	addLow		= false; 
			bool	updateHigh	= false; 
			bool	updateLow	= false; 

			zigZagHighZigZags.Set(0);
			zigZagLowZigZags.Set(0);

			if (!isSwingHigh && !isSwingLow)
			{
				zigZagHighSeries.Set(currentZigZagHigh);
				zigZagLowSeries.Set(currentZigZagLow);
				return;
			}
			
			if (trendDir <= 0 && isSwingHigh && isOverHighDeviation)
			{	
				saveValue	= highSeries[1];
				addHigh		= true;
				trendDir	= 1;
			}	
			else if (trendDir >= 0 && isSwingLow && isOverLowDeviation)
			{	
				saveValue	= lowSeries[1];
				addLow		= true;
				trendDir	= -1;
			}	
			else if (trendDir == 1 && isSwingHigh && IsPriceGreater(highSeries[1], lastSwingPrice)) 
			{
				saveValue	= highSeries[1];
				updateHigh	= true;
			}
			else if (trendDir == -1 && isSwingLow && IsPriceGreater(lastSwingPrice, lowSeries[1])) 
			{
				saveValue	= lowSeries[1];
				updateLow	= true;
			}

			if (addHigh || addLow || updateHigh || updateLow)
			{
				if (updateHigh && lastSwingIdx >= 0)
				{
					zigZagHighZigZags.Set(CurrentBar - lastSwingIdx, 0);
					Value.Reset(CurrentBar - lastSwingIdx);
				}
				else if (updateLow && lastSwingIdx >= 0)
				{
					zigZagLowZigZags.Set(CurrentBar - lastSwingIdx, 0);
					Value.Reset(CurrentBar - lastSwingIdx);
				}

				if (addHigh || updateHigh)
				{
					zigZagHighZigZags.Set(1, saveValue);
					zigZagHighZigZags.Set(0, 0);

					currentZigZagHigh = saveValue;
					zigZagHighSeries.Set(1, currentZigZagHigh);
					Value.Set(1, currentZigZagHigh);
				}
				else if (addLow || updateLow) 
				{
					zigZagLowZigZags.Set(1, saveValue);
					zigZagLowZigZags.Set(0, 0);

					currentZigZagLow = saveValue;
					zigZagLowSeries.Set(1, currentZigZagLow);
					Value.Set(1, currentZigZagLow);
				}

				lastSwingIdx	= CurrentBar - 1;
				lastSwingPrice	= saveValue;
			}

			zigZagHighSeries.Set(currentZigZagHigh);
			zigZagLowSeries.Set(currentZigZagLow);
        }

        #region Properties
        [Description("Deviation in percent or points regarding on the deviation type")]
        [GridCategory("Parameters")]
		[Gui.Design.DisplayName("Deviation value")]
        public double DeviationValue
        {
            get { return deviationValue; }
            set { deviationValue = Math.Max(0.0, value); }
        }

        [Description("Type of the deviation value")]
        [GridCategory("Parameters")]
		[Gui.Design.DisplayName("Deviation type")]
        public DeviationType DeviationType
        {
            get { return deviationType; }
            set { deviationType = value; }
        }

        [Description("If true, high and low instead of selected price type is used to plot indicator.")]
        [GridCategory("Parameters")]
		[Gui.Design.DisplayName("Use high and low")]
		[RefreshProperties(RefreshProperties.All)]
        public bool UseHighLow
        {
            get { return useHighLow; }
            set { useHighLow = value; }
        }

		/// <summary>
		/// Gets the ZigZag high points.
		/// </summary>
		[Browsable(false)]
		[XmlIgnore()]
		public DataSeries ZigZagHigh
		{
			get 
			{ 
				Update();
				return zigZagHighSeries; 
			}
		}

		/// <summary>
		/// Gets the ZigZag low points.
		/// </summary>
		[Browsable(false)]
		[XmlIgnore()]
		public DataSeries ZigZagLow
		{
			get 
			{ 
				Update();
				return zigZagLowSeries; 
			}
		}
        #endregion

		#region Miscellaneous

		/// <summary>
		/// #ENS#
		/// </summary>
		/// <param name="chartControl"></param>
		/// <param name="min"></param>
		/// <param name="max"></param>
		public override void GetMinMaxValues(Gui.Chart.ChartControl chartControl, ref double min, ref double max)
		{
			if (BarsArray[0] == null || ChartControl == null)
				return;

			for (int seriesCount = 0; seriesCount < Values.Length; seriesCount++)
			{
				for (int idx = this.FirstBarIndexPainted; idx <= this.LastBarIndexPainted; idx++)
				{
					if (zigZagHighZigZags.IsValidPlot(idx) && zigZagHighZigZags.Get(idx) != 0)
						max = Math.Max(max, zigZagHighZigZags.Get(idx));
					if (zigZagLowZigZags.IsValidPlot(idx) && zigZagLowZigZags.Get(idx) != 0)
						min = Math.Min(min, zigZagLowZigZags.Get(idx));
				}
			}
		}

		private bool IsPriceGreater(double a, double b)
		{
			if (a > b && a - b > TickSize / 2)
				return true; 
			else 
				return false;
		}

		public override void Plot(Graphics graphics, Rectangle bounds, double min, double max)
		{
			if (Bars == null || ChartControl == null)
				return;

			IsValidPlot(Bars.Count - 1 + (CalculateOnBarClose ? -1 : 0)); // make sure indicator is calculated until last (existing) bar

			int preDiff = 1;
			for (int i = FirstBarIndexPainted - 1; i >= BarsRequired; i--)
			{
				if (i < 0)
					break;

				bool isHigh	= zigZagHighZigZags.IsValidPlot(i) && zigZagHighZigZags.Get(i) > 0;
				bool isLow	= zigZagLowZigZags.IsValidPlot(i) && zigZagLowZigZags.Get(i) > 0;
				
				if (isHigh || isLow)
					break;

				preDiff++;
			}

			int postDiff = 0;
			for (int i = LastBarIndexPainted; i <= zigZagHighZigZags.Count; i++)
			{
				if (i < 0)
					break;

				bool isHigh	= zigZagHighZigZags.IsValidPlot(i) && zigZagHighZigZags.Get(i) > 0;
				bool isLow	= zigZagLowZigZags.IsValidPlot(i) && zigZagLowZigZags.Get(i) > 0;

				if (isHigh || isLow)
					break;

				postDiff++;
			}

			bool linePlotted = false;
			using (GraphicsPath path = new GraphicsPath()) 
			{
				int		barWidth	= ChartControl.ChartStyle.GetBarPaintWidth(Bars.BarsData.ChartStyle.BarWidthUI);

				int		lastIdx		= -1; 
				double	lastValue	= -1; 

				for (int idx = this.FirstBarIndexPainted - preDiff; idx <= this.LastBarIndexPainted + postDiff; idx++)
				{
					if (idx - Displacement < 0 || idx - Displacement >= Bars.Count || (!ChartControl.ShowBarsRequired && idx - Displacement < BarsRequired))
						continue;

					bool isHigh	= zigZagHighZigZags.IsValidPlot(idx) && zigZagHighZigZags.Get(idx) > 0;
					bool isLow	= zigZagLowZigZags.IsValidPlot(idx) && zigZagLowZigZags.Get(idx) > 0;

					if (!isHigh && !isLow)
						continue;
					
					double value = isHigh ? zigZagHighZigZags.Get(idx) : zigZagLowZigZags.Get(idx);
					if (lastValue >= 0)
					{	
						int x0	= ChartControl.GetXByBarIdx(BarsArray[0], lastIdx);
						int x1	= ChartControl.GetXByBarIdx(BarsArray[0], idx);
						int y0	= ChartControl.GetYByValue(this, lastValue);
						int y1	= ChartControl.GetYByValue(this, value);

						path.AddLine(x0, y0, x1, y1);
						linePlotted = true;
					}

					// save as previous point
					lastIdx		= idx; 
					lastValue	= value; 
				}

				SmoothingMode oldSmoothingMode = graphics.SmoothingMode;
				graphics.SmoothingMode = SmoothingMode.AntiAlias;
				graphics.DrawPath(Plots[0].Pen, path);
				graphics.SmoothingMode = oldSmoothingMode;
			}

			if (!linePlotted)
				DrawTextFixed("ZigZagErrorMsg", "ZigZag can't plot any values since the deviation value is too large. Please reduce it.", TextPosition.BottomRight);
		}
		
		#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 ZigZag[] cacheZigZag = null;

        private static ZigZag checkZigZag = new ZigZag();

        /// <summary>
        /// The ZigZag indicator shows trend lines filtering out changes below a defined level. 
        /// </summary>
        /// <returns></returns>
        public ZigZag ZigZag(DeviationType deviationType, double deviationValue, bool useHighLow)
        {
            return ZigZag(Input, deviationType, deviationValue, useHighLow);
        }

        /// <summary>
        /// The ZigZag indicator shows trend lines filtering out changes below a defined level. 
        /// </summary>
        /// <returns></returns>
        public ZigZag ZigZag(Data.IDataSeries input, DeviationType deviationType, double deviationValue, bool useHighLow)
        {
            if (cacheZigZag != null)
                for (int idx = 0; idx < cacheZigZag.Length; idx++)
                    if (cacheZigZag[idx].DeviationType == deviationType && Math.Abs(cacheZigZag[idx].DeviationValue - deviationValue) <= double.Epsilon && cacheZigZag[idx].UseHighLow == useHighLow && cacheZigZag[idx].EqualsInput(input))
                        return cacheZigZag[idx];

            lock (checkZigZag)
            {
                checkZigZag.DeviationType = deviationType;
                deviationType = checkZigZag.DeviationType;
                checkZigZag.DeviationValue = deviationValue;
                deviationValue = checkZigZag.DeviationValue;
                checkZigZag.UseHighLow = useHighLow;
                useHighLow = checkZigZag.UseHighLow;

                if (cacheZigZag != null)
                    for (int idx = 0; idx < cacheZigZag.Length; idx++)
                        if (cacheZigZag[idx].DeviationType == deviationType && Math.Abs(cacheZigZag[idx].DeviationValue - deviationValue) <= double.Epsilon && cacheZigZag[idx].UseHighLow == useHighLow && cacheZigZag[idx].EqualsInput(input))
                            return cacheZigZag[idx];

                ZigZag indicator = new ZigZag();
                indicator.BarsRequired = BarsRequired;
                indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
                indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
                indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
                indicator.Input = input;
                indicator.DeviationType = deviationType;
                indicator.DeviationValue = deviationValue;
                indicator.UseHighLow = useHighLow;
                Indicators.Add(indicator);
                indicator.SetUp();

                ZigZag[] tmp = new ZigZag[cacheZigZag == null ? 1 : cacheZigZag.Length + 1];
                if (cacheZigZag != null)
                    cacheZigZag.CopyTo(tmp, 0);
                tmp[tmp.Length - 1] = indicator;
                cacheZigZag = tmp;
                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>
        /// The ZigZag indicator shows trend lines filtering out changes below a defined level. 
        /// </summary>
        /// <returns></returns>
        [Gui.Design.WizardCondition("Indicator")]
        public Indicator.ZigZag ZigZag(DeviationType deviationType, double deviationValue, bool useHighLow)
        {
            return _indicator.ZigZag(Input, deviationType, deviationValue, useHighLow);
        }

        /// <summary>
        /// The ZigZag indicator shows trend lines filtering out changes below a defined level. 
        /// </summary>
        /// <returns></returns>
        public Indicator.ZigZag ZigZag(Data.IDataSeries input, DeviationType deviationType, double deviationValue, bool useHighLow)
        {
            return _indicator.ZigZag(input, deviationType, deviationValue, useHighLow);
        }
    }
}

// This namespace holds all strategies and is required. Do not change it.
namespace NinjaTrader.Strategy
{
    public partial class Strategy : StrategyBase
    {
        /// <summary>
        /// The ZigZag indicator shows trend lines filtering out changes below a defined level. 
        /// </summary>
        /// <returns></returns>
        [Gui.Design.WizardCondition("Indicator")]
        public Indicator.ZigZag ZigZag(DeviationType deviationType, double deviationValue, bool useHighLow)
        {
            return _indicator.ZigZag(Input, deviationType, deviationValue, useHighLow);
        }

        /// <summary>
        /// The ZigZag indicator shows trend lines filtering out changes below a defined level. 
        /// </summary>
        /// <returns></returns>
        public Indicator.ZigZag ZigZag(Data.IDataSeries input, DeviationType deviationType, double deviationValue, bool useHighLow)
        {
            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.ZigZag(input, deviationType, deviationValue, useHighLow);
        }
    }
}
#endregion
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

TheCycleCode said:
Well, thank you for your kind words and refreshing open mind.

Cordially,
Michael Calhoun
Juris Doctorate
Click to expand...

Michael,

How did you calculate the next price projection based on the current expected SP500 top at 9th Vector? Based on the 11/16th low price projection is much downwards isn't it ? Are you using a different low ?

Regards
AJV
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

ajv said:
Michael,

How did you calculate the next price projection based on the current expected SP500 top at 9th Vector? Based on the 11/16th low price projection is much downwards isn't it ? Are you using a different low ?

Regards
AJV
Click to expand...

Read my last 3 posts, and notice he hasn't replied...
Tarting up standard charting package indicators with a few
meaningless bells and whistles is quite common and easy.

You have to do the work yourself.
No one is going to give you / or sell you anything of worth.
Think about it, if it really worked, would you sell it, no you wouldn't.
You may not want to hear that, but its the truth.
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

ajv said:
Michael,

How did you calculate the next price projection based on the current expected SP500 top at 9th Vector? Based on the 11/16th low price projection is much downwards isn't it ? Are you using a different low ?

Regards
AJV
Click to expand...

Erm....all your posts relate to this thread and you ignore notes of caution from other traders - are you his patsy planted here to add dubious authenticity to his spin? I would like to think that you come across as one who is not so stupid as to fall for this type of hype, especially if you take note of the warnings alluded to in the posts above:)
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

ajv said:
Michael,

How did you calculate the next price projection based on the current expected SP500 top at 9th Vector? Based on the 11/16th low price projection is much downwards isn't it ? Are you using a different low ?

Regards
AJV
Click to expand...

The forecast of May 20th for the S&P 500 of 1435.61 was based on the trend line between the previous cycle high (9/14/12) and the high of 3/12/13.

The high of 3/12/13 was taken out before a 1.793% pullback, so the 5th wave (9th vector) is still under construction. So we are waiting for a 1793% pullback from the current high to enter a short SPY options trade with a June expiration.

The forecast is made by taking the trend line of the last two cycle highs and projecting it from the intervening cycle low (11/16/12 @ 1343.35).

That takes the price/time energy of the current cycle and projects it into the next vector trend.

Congratulations for thinking for yourself! I don't believe there were any other questions in the other replies, just comments.

Stocks & Commodities have accepted for publication our article based on the 3/5 wave cycle and forecasting model. Hope you take a look there, too.

Cordially,
Michael Calhoun
Juris Doctorate
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

Liquid validity said:
Yes and you avoidance of answering them is noted.
I'll ask again anyway:
http://www.trade2win.com/boards/fut...-tops-bottoms-hourly-chart-6.html#post2094504
http://www.trade2win.com/boards/fut...-tops-bottoms-hourly-chart-6.html#post2094516
Click to expand...

I'm not familiar with the "zig zag ninja trader", and The Cycle Code is not related to it. I'm not sure what the question is in the algorithm posted.

Cordially,
Michael Calhoun
Juris Doctorate
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

TheCycleCode said:
I'm not familiar with the "zig zag ninja trader", and The Cycle Code is not related to it. I'm not sure what the question is in the algorithm posted.

Cordially,
Michael Calhoun
Juris Doctorate
Click to expand...

There are similarities in the plot characteristics.
As no live demonstration of this has been done,
how are people to know that it doesn't suffer from
debilitating lag, as the indicator I used as an example does.
There is no justification without live results or proof of them.
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

Liquid validity said:
There are similarities in the plot characteristics.
As no live demonstration of this has been done,
how are people to know that it doesn't suffer from
debilitating lag, as the indicator I used as an example does.
Click to expand...

This 1.793% cycle concludes approximately every other month. I've indicated that a 1.793% pull back in price will inaugurate a short vector minor trend, and our subscribers trading this cycle will enter a short SPY trade when that pullback occurs.

Under our trade rules, 1/2 of the trade (all of the investment capital) will be taken off the table upon a 100% return in that June SPY option investment, and the second half exit is triggered by price movement to the forecasted price, or the completion of the 3rd wave, whichever occurs first.

I'm not sure what you mean by debilitating lag. All the vectors in The Cycle Code are defined by 1.793% minimum price retracements. They cannot be recalculated. I've previously posted one cycle up close and a three years bird-eye chart.

Whether the wave trend is 3 or 5 may be unclear at times, especially during sideways moving markets. We don't trade unclear trends. But we're not in a sideways moving market - at least not in the 1.793% cycle on the hourly fractal.

Cordially,
Michael Calhoun
Juris Doctorate
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

TheCycleCode said:
This 1.793% cycle concludes approximately every other month. I've indicated that a 1.793% pull back in price will inaugurate a short vector minor trend, and our subscribers trading this cycle will enter a short SPY trade when that pullback occurs.

Under our trade rules, 1/2 of the trade (all of the investment capital) will be taken off the table upon a 100% return in that June SPY option investment, and the second half exit is triggered by price movement to the forecasted price, or the completion of the 3rd wave, whichever occurs first.

I'm not sure what you mean by debilitating lag. All the vectors in The Cycle Code are defined by 1.793% minimum price retracements. They cannot be recalculated. I've previously posted one cycle up close and a three years bird-eye chart.

Whether the wave trend is 3 or 5 may be unclear at times, especially during sideways moving markets. We don't trade unclear trends. But we're not in a sideways moving market - at least not in the 1.793% cycle on the hourly fractal.

Cordially,
Michael Calhoun
Juris Doctorate
Click to expand...

This just gets better and better...and my earlier post said it was complete bollox, this has taken it to a whole new level
cordially
malaguti
 
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

20130612-002.png


Honestly I think that is just a common Zig-Zag indicator which plots after the fact. That is how it looks so good - it has the benefit of hindsight. If it plotted in real time and placed those tops and bottoms I would own it already. :whistling m

btw a zig zag works off vectors fyi which are just close approximates till a swing high or swing low has been established by some X bars back.
 
Last edited:
Re: The Stunning Price Cycle Calling The S&P 500 Tops & Bottoms On The Hourly Chart

Mark and Malaguti. I like your Qs about the cycle presentation by Michael Calhoun.

Michael. I like your charts and your presentation too. I work with not exactly cycles but something similar.

Michael. I think that the best way to really make my jaw drop is if you where to do your charts from left to right projecting into the future. We/I are tire of seeing "perfection" to the left of charts. Any system is perfect to the left.

Yes i know it will take time for the projection to unfold but that's the only way you will make believers out me and many others.

regards,
Brazza
:)
 
Last edited:
You must log in or register to reply here.

Similar threads

D
Why S&P 500 will be much higher in 5 years?
2 3
Replies
59
Views
15K
Duarte
D
N
S&P 500 Help
Replies
0
Views
1K
Nater
N
malaspina
Swing Trade. Emini S&P 500. Day to Day Trading.
Replies
17
Views
8K
Trader_Matt
T
G
S&P 500 top
Replies
4
Views
2K
gkareer
G
Richard Ratchford
  • Article
Technical Analysis Cycles, Trends and Pause Formation
Replies
2
Views
3K
Grey1
Grey1
Top