3rdpartylibs/fastreports.wpf/FastReport.DataVisualization/shared/Formulas/Oscillator.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.


//
//  Purpose:	This class is used to calculate oscillator 
//				indicators used in Technical Analyses.
//


using System;
using System.Globalization;

namespace FastReport.DataVisualization.Charting.Formulas
{
	/// <summary>
	/// This class is used to calculate oscillator 
	///	indicators used in Technical Analyses.
	/// </summary>
	internal class Oscillators : PriceIndicators
	{
		#region Properties

		/// <summary>
		/// Formula Module name
		/// </summary>
		override public string Name			{ get{ return "Oscillators";}}

		#endregion

		#region Formulas

		/// <summary>
		/// The Chaikin Oscillator is created by subtracting a 10 period 
		/// exponential moving average of the Accumulation/Distribution 
		/// line from a 3 period moving average of the 
		/// Accumulation/Distribution Line. 
		/// ---------------------------------------------------------
		/// Input: 
		///		- 4 Y values ( Hi, Low, Close, Volume ).
		/// Output: 
		///		- 1 Y value Chaikin Oscillator
		/// Parameters: 
		///		- Short Period for Exponential Moving average (default=3)
		///		- Int64 Period for Exponential Moving average (default=10)
		///	Extra Parameters: 
		///		- Start from First
		/// </summary>
		/// <param name="inputValues">Arrays of doubles - Input values</param>
		/// <param name="outputValues">Arrays of doubles - Output values</param>
		/// <param name="parameterList">Array of strings - Parameters</param>
		/// <param name="extraParameterList">Array of strings - Extra parameters</param>
		private void ChaikinOscillator(double [][] inputValues, out double [][] outputValues, string [] parameterList, string [] extraParameterList)
		{
			// There is no enough input series
			if( inputValues.Length != 5 )
			{
				throw new ArgumentException( SR.ExceptionPriceIndicatorsFormulaRequiresFourArrays);
			}
						
			// Different number of x and y values
			CheckNumOfValues( inputValues, 4 );

			// Short Period for Exp moving average
			int shortPeriod;
            if (parameterList.Length < 1 || 
                !int.TryParse(parameterList[0], NumberStyles.Any, CultureInfo.InvariantCulture, out shortPeriod))
            {
                shortPeriod = 3;
            }
			
			// Int64 Period for Exp moving average
			int longPeriod;
            if (parameterList.Length < 2 || 
                !int.TryParse(parameterList[1], NumberStyles.Any, CultureInfo.InvariantCulture, out longPeriod))
            {
                longPeriod = 10;
            }

			if( shortPeriod > longPeriod || longPeriod <= 0 || shortPeriod <= 0 )
			{
                throw new ArgumentException(SR.ExceptionOscillatorObjectInvalidPeriod);
			}

			// Starting average from the first data point or after period.
			bool startFromFirst = bool.Parse( extraParameterList[0] );

			VolumeIndicators volume = new VolumeIndicators();

			double [][] outputDistribution = new double [2][];

			// Accumulation Distribution
			volume.AccumulationDistribution( inputValues, out outputDistribution );

			double [] ExpAvgDistribution;

			// Exponential Moving average of Accumulation Distribution
			ExponentialMovingAverage(outputDistribution[1],out ExpAvgDistribution,longPeriod,startFromFirst);

			double [] ExpAvg;

			// Exponential Moving average of close
			ExponentialMovingAverage(outputDistribution[1],out ExpAvg,shortPeriod,startFromFirst);

			outputValues = new double [2][];

			int period = Math.Min(ExpAvg.Length,ExpAvgDistribution.Length);

			outputValues[0] = new double [period];
			outputValues[1] = new double [period];

			// Accumulation Distribution
			int expIndex = 0;
			for( int index = inputValues[1].Length - period; index < inputValues[1].Length; index++ )
			{
				// Set X values
				outputValues[0][expIndex] = inputValues[0][index];

				// Set Y values
				if(startFromFirst)
				{
					// Number of items in all arays is the same and they are aligned by time.
					outputValues[1][expIndex] = ExpAvg[expIndex] - ExpAvgDistribution[expIndex];
				}
				else if( (expIndex + longPeriod - shortPeriod) < ExpAvg.Length)
				{
					// Number of items in MovingAverages arrays is different and requires adjustment.
					outputValues[1][expIndex] = ExpAvg[expIndex + longPeriod - shortPeriod] - ExpAvgDistribution[expIndex];
				}
				else
				{
					outputValues[1][expIndex] = Double.NaN;
				}
				expIndex++;
			}
		}

		/// <summary>
		/// The Detrended Price Oscillator ("DPO") attempts to 
		/// eliminate the trend in prices. Detrended prices allow 
		/// you to more easily identify cycles and overbought/oversold 
		/// levels. To calculate the DPO, you specify a time period. 
		/// Cycles longer than this time period are removed from 
		/// prices, leaving the shorter-term cycles. 
		/// ---------------------------------------------------------
		/// Input: 
		///		- 1 Y value ( Close ).
		/// Output: 
		///		- 1 Y value Detrended Price Oscillator
		/// Parameters: 
		///		- Period
		/// </summary>
		/// <param name="inputValues">Arrays of doubles - Input values</param>
		/// <param name="outputValues">Arrays of doubles - Output values</param>
		/// <param name="parameterList">Array of strings - Parameters</param>
		private void DetrendedPriceOscillator(double [][] inputValues, out double [][] outputValues, string [] parameterList)
		{
			// There is no enough input series
			if( inputValues.Length != 2 )
			{
                throw new ArgumentException(SR.ExceptionPriceIndicatorsFormulaRequiresOneArray);
			}
			
			// Different number of x and y values
			CheckNumOfValues( inputValues, 1 );
			
			// Short Period for Exp moving average
			int period;
			try
			{period = int.Parse( parameterList[0], System.Globalization.CultureInfo.InvariantCulture );}
			catch( Exception e )
			{
                if (e.Message == SR.ExceptionObjectReferenceIsNull)
                    throw new InvalidOperationException(SR.ExceptionPriceIndicatorsPeriodMissing);
				else
                    throw new InvalidOperationException(SR.ExceptionPriceIndicatorsPeriodMissing + e.Message);
			}

			if( period <= 0 )
                throw new InvalidOperationException(SR.ExceptionPeriodParameterIsNegative);

			double [] outputAverage;

			// Moving Average
			MovingAverage( inputValues[1], out outputAverage, period, false );
			
			outputValues = new double [2][];

			outputValues[0] = new double [inputValues[0].Length - period*3/2];
			outputValues[1] = new double [inputValues[1].Length - period*3/2];

			// Detrended Price Oscillator
			for( int index = 0; index < outputValues[1].Length; index++ )
			{
				// Set X values
				outputValues[0][index] = inputValues[0][index + period + period/2];

				// Set Y values
				outputValues[1][index] = inputValues[1][index + period + period/2] - outputAverage[index];
			}
		}

		/// <summary>
		/// Chaikin's Volatility indicator compares the spread 
		/// between a security's high and low prices. 
		/// It quantifies volatility as a widening of the range 
		/// between the high and the low price. There are two ways 
		/// to interpret this measure of volatility. One method 
		/// assumes that market tops are generally accompanied by 
		/// increased volatility (as investors get nervous and 
		/// indecisive) and that the latter stages of a market 
		/// bottom are generally accompanied by decreased volatility 
		/// (as investors get bored). Another method (Mr. Chaikin's) 
		/// assumes that an increase in the Volatility indicator over 
		/// a relatively short time period indicates that a bottom is 
		/// near (e.g., a panic sell-off) and that a decrease in 
		/// volatility over a longer time period indicates an 
		/// approaching top (e.g., a mature bull market). As with 
		/// almost all experienced investors, Mr. Chaikin recommends 
		/// that you do not rely on any one indicator. He suggests 
		/// using a moving average penetration or trading band system 
		/// to confirm this (or any) indicator.
		/// ---------------------------------------------------------
		/// Input: 
		///		- 2 Y values ( Hi, Low ).
		/// Output: 
		///		- 1 Y value Volatility Chaikins
		/// Parameters: 
		///		- Periods (default 10)- is used to specify the Shift days, By default this property is set to 10.
		///     - SignalPeriod (default 10)- is used to calculate Exponential Moving Avg of the Signal line, By default this property is set to 10.
		/// </summary>
		/// <param name="inputValues">Arrays of doubles - Input values</param>
		/// <param name="outputValues">Arrays of doubles - Output values</param>
		/// <param name="parameterList">Array of strings - Parameters</param>
		private void VolatilityChaikins(double [][] inputValues, out double [][] outputValues, string [] parameterList)
		{
			// There is no enough input series
			if( inputValues.Length != 3 )
			{
				throw new ArgumentException( SR.ExceptionPriceIndicatorsFormulaRequiresTwoArrays);
			}
			
			// Different number of x and y values
			CheckNumOfValues( inputValues, 2 );
						
			// Period
			int period;
            if (parameterList.Length < 1 ||
                !int.TryParse(parameterList[0], NumberStyles.Any, CultureInfo.InvariantCulture, out period))
            {
                period = 10;
            }

			if( period <= 0 )
                throw new InvalidOperationException(SR.ExceptionOscillatorNegativePeriodParameter);

			// Signal Period for Exp moving average
			int signalPeriod;
            if (parameterList.Length < 2 ||
                !int.TryParse(parameterList[1], NumberStyles.Any, CultureInfo.InvariantCulture, out signalPeriod))
            {
                signalPeriod = 10;
            }

			if( signalPeriod <= 0 )
                throw new InvalidOperationException(SR.ExceptionOscillatorNegativeSignalPeriod);

			double [] outputAverage;

			double [] hiLowInput = new double[inputValues[1].Length];

			// Find Hi - Low
			for( int index = 0; index < inputValues[1].Length; index++ )
			{
				hiLowInput[index] = inputValues[1][index] - inputValues[2][index];
			}
            
			// Exponential Moving Average
			ExponentialMovingAverage( hiLowInput, out outputAverage, signalPeriod, false );
			
			outputValues = new double [2][];

			outputValues[0] = new double [outputAverage.Length - period];
			outputValues[1] = new double [outputAverage.Length - period];

			// Volatility Chaikins
			for( int index = 0; index < outputValues[1].Length; index++ )
			{
				// Set X values
				outputValues[0][index] = inputValues[0][index + period + signalPeriod - 1];

				// Set Y values
				if( outputAverage[index] != 0.0 )
					outputValues[1][index] = ( outputAverage[index + period] - outputAverage[index] ) / outputAverage[index] * 100.0;
				else
					// Div with zero error.
					outputValues[1][index] = 0.0;
			}
		}

		/// <summary>
		/// The Volume Oscillator displays the difference between two 
		/// moving averages of a security's volume. The difference 
		/// between the moving averages can be expressed in either 
		/// points or percentages. You can use the difference between 
		/// two moving averages of volume to determine if the overall 
		/// volume trend is increasing or decreasing. When the Volume 
		/// Oscillator rises above zero, it signifies that the 
		/// shorter-term volume moving average has risen above 
		/// the longer-term volume moving average, and thus, that 
		/// the short-term volume trend is higher (i.e., more volume) 
		/// than the longer-term volume trend.
		/// ---------------------------------------------------------
		/// Input: 
		///		- 1 Y values ( Volume ).
		/// Output: 
		///		- 1 Y value VolumeOscillator
		/// Parameters: 
		///		- ShortPeriod (Default 5)= is used to configure the short period.
		///		- LongPeriod (Default 10)= is used to configure the Int64 period.
		///		- Percentage (Default true)= The Volume Oscillator can display the difference between the two moving averages as either points or percentages.
		/// </summary>
		/// <param name="inputValues">Arrays of doubles - Input values</param>
		/// <param name="outputValues">Arrays of doubles - Output values</param>
		/// <param name="parameterList">Array of strings - Parameters</param>
		private void VolumeOscillator(double [][] inputValues, out double [][] outputValues, string [] parameterList)
		{
			// There is no enough input series
			if( inputValues.Length != 2 )
			{
                throw new ArgumentException(SR.ExceptionPriceIndicatorsFormulaRequiresOneArray);
			}
			
			// Different number of x and y values
			CheckNumOfValues( inputValues, 1 );
						
			// Short Period
			int shortPeriod;
            if (parameterList.Length < 1 || 
                !int.TryParse(parameterList[0], NumberStyles.Any, CultureInfo.InvariantCulture, out shortPeriod))
            {
                shortPeriod = 5;
            }

			// Int64 Period
			int longPeriod;
            if (parameterList.Length < 2 || 
                !int.TryParse(parameterList[1], NumberStyles.Any, CultureInfo.InvariantCulture, out longPeriod))
            {
                longPeriod = 10;
            }

			if( shortPeriod > longPeriod || longPeriod <= 0 || shortPeriod <= 0 )
                throw new ArgumentException(SR.ExceptionOscillatorObjectInvalidPeriod);

			// percentage
			bool percentage;
            if (parameterList.Length < 3 || 
                !bool.TryParse(parameterList[2], out percentage))
            {
                percentage = true;
            }
			
			double [] shortAverage;
			double [] longAverage;

			// Find Short moving average
			MovingAverage( inputValues[1], out shortAverage, shortPeriod, false );

			// Find Int64 moving average
			MovingAverage( inputValues[1], out longAverage, longPeriod, false );

			outputValues = new double [2][];

			outputValues[0] = new double [longAverage.Length];
			outputValues[1] = new double [longAverage.Length];
			
			// Volume Oscillator
			for( int index = 0; index < longAverage.Length; index++ )
			{
				// Set X values
				outputValues[0][index] = inputValues[0][index + longPeriod-1];

				// Set Y values
				outputValues[1][index] = shortAverage[index + shortPeriod] - longAverage[index];

				// RecalculateAxesScale difference in %
				if( percentage )
				{
					// Div by zero error.
					if( longAverage[index] == 0.0 )
						outputValues[1][index]=0.0;
					else
						outputValues[1][index] = outputValues[1][index] / shortAverage[index + shortPeriod] * 100;
				}
			}
		}

		/// <summary>
		/// The Stochastic Indicator is based on the observation that 
		/// as prices increase, closing prices tend to accumulate ever 
		/// closer to the highs for the period. Conversely, as prices 
		/// decrease, closing prices tend to accumulate ever closer to 
		/// the lows for the period. Trading decisions are made with 
		/// respect to divergence between % of "D" (one of the two 
		/// lines generated by the study) and the item's price. For 
		/// example, when a commodity or stock makes a high, reacts, 
		/// and subsequently moves to a higher high while corresponding 
		/// peaks on the % of "D" line make a high and then a lower 
		/// high, a bearish divergence is indicated. When a commodity 
		/// or stock has established a new low, reacts, and moves to a 
		/// lower low while the corresponding low points on the % of 
		/// "D" line make a low and then a higher low, a bullish 
		/// divergence is indicated. Traders act upon this divergence 
		/// when the other line generated by the study (K) crosses on 
		/// the right-hand side of the peak of the % of "D" line in the 
		/// case of a top, or on the right-hand side of the low point 
		/// of the % of "D" line in the case of a bottom. The Stochastic 
		/// Oscillator is displayed as two lines. The main line is 
		/// called "%K." The second line, called "%D," is a moving 
		/// average of %K. 
		/// ---------------------------------------------------------
		/// Input: 
		///		- 3 Y values ( Hi, Low, Close ).
		/// Output: 
		///		- 2 Y value ( %K, %D )
		/// Parameters: 
		///		- PeriodD (Default 10) = is used for %D calculation as SMA of %K.
		///     - PeriodK (Default 10) = is used to calculate %K.
		/// </summary>
		/// <param name="inputValues">Arrays of doubles - Input values</param>
		/// <param name="outputValues">Arrays of doubles - Output values</param>
		/// <param name="parameterList">Array of strings - Parameters</param>
		internal void StochasticIndicator(double [][] inputValues, out double [][] outputValues, string [] parameterList)
		{
			// There is no enough input series
			if( inputValues.Length != 4 )
			{
				throw new ArgumentException( SR.ExceptionPriceIndicatorsFormulaRequiresThreeArrays);
			}
			
			// Different number of x and y values
			CheckNumOfValues( inputValues, 3 );
			
			// PeriodD for moving average
			int periodD;
            if (parameterList.Length < 2 || 
                !int.TryParse(parameterList[1], NumberStyles.Any, CultureInfo.InvariantCulture, out periodD))
            {
                periodD = 10;
            }

			if( periodD <= 0 )
                throw new InvalidOperationException(SR.ExceptionPeriodParameterIsNegative);

			// PeriodK for moving average
			int periodK;
            if (parameterList.Length < 1 || 
                !int.TryParse(parameterList[0], NumberStyles.Any, CultureInfo.InvariantCulture, out periodK))
            {
                periodK = 10;
            }

			if( periodK <= 0 )
                throw new InvalidOperationException(SR.ExceptionPeriodParameterIsNegative);

			// Output arrays
			outputValues = new double [3][];

			// X
			outputValues[0] = new double [inputValues[0].Length - periodK - periodD + 2];

			// K%
			outputValues[1] = new double [inputValues[0].Length - periodK - periodD + 2];

			// D%
			outputValues[2] = new double [inputValues[0].Length - periodK - periodD + 2];

			double [] K = new double [inputValues[0].Length - periodK + 1];

			// Find K%
			for( int index = periodK - 1; index < inputValues[0].Length; index++ )
			{
				// Find Lowest Low and Highest High
				double minLow = double.MaxValue;
				double maxHi = double.MinValue;
				for( int indexHL = index - periodK + 1; indexHL <= index; indexHL++ )
				{
					if( minLow > inputValues[2][indexHL] )
						minLow = inputValues[2][indexHL];

					if( maxHi < inputValues[1][indexHL] )
						maxHi = inputValues[1][indexHL];
				}
				// Find K%
				K[index - periodK + 1] = ( inputValues[3][index] - minLow ) / ( maxHi - minLow ) * 100;

				// Set X and Y K output
				if( index >= periodK + periodD - 2 )
				{
					outputValues[0][index - periodK - periodD + 2] = inputValues[0][index];
					outputValues[1][index - periodK - periodD + 2] = K[index - periodK + 1];
				}
			}

			// Find D%
			MovingAverage( K, out outputValues[2], periodD, false );
		}

		/// <summary>
		/// Williams’ %R (pronounced "percent R") is a momentum 
		/// indicator that measures overbought/oversold levels. 
		/// Williams’ %R was developed by Larry Williams. The 
		/// interpretation of Williams' %R is very similar to that 
		/// of the Stochastic Oscillator except that %R is plotted 
		/// upside-down and the Stochastic Oscillator has internal 
		/// smoothing. To display the Williams’ %R indicator on an 
		/// upside-down scale, it is usually plotted using negative 
		/// values (e.g., -20%). Readings in the range of 80 to 100% 
		/// indicate that the security is oversold while readings in 
		/// the 0 to 20% range suggest that it is overbought.
		/// As with all overbought/oversold indicators, it is best to 
		/// wait for the security's price to change direction before 
		/// placing your trades. For example, if an overbought/oversold 
		/// indicator (such as the Stochastic Oscillator or Williams' 
		/// %R) is showing an overbought condition, it is wise to wait 
		/// for the security's price to turn down before selling the 
		/// security. (The MovingAverageConvergenceDivergence is a good indicator to monitor change 
		/// in a security's price.) It is not unusual for 
		/// overbought/oversold indicators to remain in an 
		/// overbought/oversold condition for a long time period as 
		/// the security's price continues to climb/fall. Selling 
		/// simply because the security appears overbought may take 
		/// you out of the security long before its price shows signs 
		/// of deterioration.
		/// ---------------------------------------------------------
		/// Input: 
		///		- 3 Y values ( Hi, Low, Close ).
		/// Output: 
		///		- 2 Y value ( %R )
		/// Parameters: 
		///		- Period (Default 14) = is used to configure the number of periods to calculate the WilliamsR
		/// </summary>
		/// <param name="inputValues">Arrays of doubles - Input values</param>
		/// <param name="outputValues">Arrays of doubles - Output values</param>
		/// <param name="parameterList">Array of strings - Parameters</param>
		internal void WilliamsR(double [][] inputValues, out double [][] outputValues, string [] parameterList)
		{
			// There is no enough input series
			if( inputValues.Length != 4 )
				throw new ArgumentException( SR.ExceptionPriceIndicatorsFormulaRequiresThreeArrays);
			
			// Different number of x and y values
			CheckNumOfValues( inputValues, 3 );
			
			// PeriodD for moving average
			int period;
            if (parameterList.Length < 1 || 
                !int.TryParse(parameterList[0], NumberStyles.Any, CultureInfo.InvariantCulture, out period))
            {
                period = 14;
            }

			if( period <= 0 )
                throw new InvalidOperationException(SR.ExceptionPeriodParameterIsNegative);

			// Output arrays
			outputValues = new double [2][];

			// X
			outputValues[0] = new double [inputValues[0].Length - period + 1];

			// R%
			outputValues[1] = new double [inputValues[0].Length - period + 1];

			// Find R%
			for( int index = period - 1; index < inputValues[0].Length; index++ )
			{
				// Find Lowest Low and Highest High
				double minLow = double.MaxValue;
				double maxHi = double.MinValue;
				for( int indexHL = index - period + 1; indexHL <= index; indexHL++ )
				{
					if( minLow > inputValues[2][indexHL] )
						minLow = inputValues[2][indexHL];

					if( maxHi < inputValues[1][indexHL] )
						maxHi = inputValues[1][indexHL];
				}
				// Set X value
				outputValues[0][index - period + 1] = inputValues[0][index];

				// Find R%
				outputValues[1][index - period + 1] = ( maxHi - inputValues[3][index] ) / ( maxHi - minLow ) * (-100.0);
			}
		}

		#endregion

		#region Methods

		/// <summary>
		/// Constructor
		/// </summary>
		public Oscillators()
		{
		}


        /// <summary>
        /// The first method in the module, which converts a formula 
        /// name to the corresponding private method.
        /// </summary>
        /// <param name="formulaName">String which represent a formula name</param>
        /// <param name="inputValues">Arrays of doubles - Input values</param>
        /// <param name="outputValues">Arrays of doubles - Output values</param>
        /// <param name="parameterList">Array of strings - Formula parameters</param>
        /// <param name="extraParameterList">Array of strings - Extra Formula parameters from DataManipulator object</param>
        /// <param name="outLabels">Array of strings - Used for Labels. Description for output results.</param>
		override public void Formula( string formulaName, double [][] inputValues, out double [][] outputValues, string [] parameterList, string [] extraParameterList, out string [][] outLabels )
		{
			string name;
			outputValues = null;

			// Not used for these formulas.
			outLabels = null;

			name = formulaName.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
			try
			{
				switch( name )
				{
					case "STOCHASTICINDICATOR":
						StochasticIndicator( inputValues, out outputValues, parameterList );
						break;
					case "CHAIKINOSCILLATOR":
						ChaikinOscillator( inputValues, out outputValues, parameterList, extraParameterList );
						break;
					case "DETRENDEDPRICEOSCILLATOR":
						DetrendedPriceOscillator( inputValues, out outputValues, parameterList );
						break;
					case "VOLATILITYCHAIKINS":
						VolatilityChaikins( inputValues, out outputValues, parameterList );
						break;
					case "VOLUMEOSCILLATOR":
						VolumeOscillator( inputValues, out outputValues, parameterList );
						break;
					case "WILLIAMSR":
						WilliamsR( inputValues, out outputValues, parameterList );
						break;
					default:
						outputValues = null;
						break;
				}
			}
			catch( IndexOutOfRangeException )
			{
				throw new InvalidOperationException( SR.ExceptionFormulaInvalidPeriod( name ) );
			}
			catch( OverflowException )
			{
				throw new InvalidOperationException( SR.ExceptionFormulaNotEnoughDataPoints( name ) );
			}
		}

		#endregion
		
	}
}