gavindiaz/QuanTAlib
1
0
Fork 0
mirror of https://github.com/mihakralj/QuanTAlib.git synced 2026-08-19 19:18:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Class optimization

Browse Source
This commit is contained in:
Miha
2024-10-27 16:11:08 -07:00
parent b2fcdda785
commit 6c67a0cf31
77 changed files with 2634 additions and 1455 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/averages/Jma.cs
+49 -40
View File
@@ -1,4 +1,4 @@
using System;
using System.Runtime.CompilerServices;
namespace QuanTAlib;
/// <summary>
@@ -32,12 +32,16 @@ public class Jma : AbstractBase
private readonly double _phase;
private readonly CircularBuffer _vsumBuff;
private readonly CircularBuffer _avoltyBuff;
private double _len1;
private double _pow1;
private readonly double _beta;
private readonly double _len1;
private readonly double _pow1;
private readonly double _oneMinusAlpha;
private readonly double _oneMinusAlphaSquared;
private readonly double _alphaSquared;
private double _upperBand, _lowerBand, _p_upperBand, _p_lowerBand;
private double _prevMa1, _prevDet0, _prevDet1, _prevJma, _p_prevMa1, _p_prevDet0, _p_prevDet1, _p_prevJma;
private double _prevMa1, _prevDet0, _prevDet1, _prevJma;
private double _p_prevMa1, _p_prevDet0, _p_prevDet1, _p_prevJma;
private double _vSum, _p_vSum;
public double UpperBand { get; set; }
@@ -45,57 +49,50 @@ public class Jma : AbstractBase
public double Volty { get; set; }
public double Factor { get; set; }
/// <summary>
/// Initializes a new instance of the Jma class with the specified parameters.
/// </summary>
/// <param name="period">The period over which to calculate the JMA.</param>
/// <param name="phase">The phase parameter (-100 to +100) controlling lag compensation.</param>
/// <param name="factor">The factor controlling volatility adaptation (default 0.45).</param>
/// <param name="buffer">The size of the volatility buffer (default 10).</param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when period is less than 1.</exception>
public Jma(int period, int phase = 0, double factor = 0.45, int buffer = 10)
{
if (period < 1)
{
throw new ArgumentOutOfRangeException(nameof(period), "Period must be greater than or equal to 1.");
throw new System.ArgumentOutOfRangeException(nameof(period), "Period must be greater than or equal to 1.");
}
Factor = factor;
_period = period;
_phase = Math.Clamp((phase * 0.01) + 1.5, 0.5, 2.5);
_phase = System.Math.Clamp((phase * 0.01) + 1.5, 0.5, 2.5);
_vsumBuff = new CircularBuffer(buffer);
_avoltyBuff = new CircularBuffer(65);
_beta = factor * (_period - 1) / (factor * (_period - 1) + 2);
_beta = factor * (period - 1) / (factor * (period - 1) + 2);
_len1 = System.Math.Max((System.Math.Log(System.Math.Sqrt(period - 1)) / System.Math.Log(2.0)) + 2.0, 0);
_pow1 = System.Math.Max(_len1 - 2.0, 0.5);
// Precalculate constants for alpha-based calculations
double alpha = System.Math.Pow(_beta, _pow1);
_oneMinusAlpha = 1.0 - alpha;
_oneMinusAlphaSquared = _oneMinusAlpha * _oneMinusAlpha;
_alphaSquared = alpha * alpha;
WarmupPeriod = period * 2;
Name = $"JMA({period})";
}
/// <summary>
/// Initializes a new instance of the Jma class with a specified source.
/// </summary>
/// <param name="source">The data source object that publishes updates.</param>
/// <param name="period">The period over which to calculate the JMA.</param>
/// <param name="phase">The phase parameter (-100 to +100) controlling lag compensation.</param>
/// <param name="factor">The factor controlling volatility adaptation (default 0.45).</param>
/// <param name="buffer">The size of the volatility buffer (default 10).</param>
public Jma(object source, int period, int phase = 0, double factor = 0.45, int buffer = 10) : this(period, phase, factor, buffer)
{
var pubEvent = source.GetType().GetEvent("Pub");
pubEvent?.AddEventHandler(source, new ValueSignal(Sub));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override void Init()
{
base.Init();
_upperBand = _lowerBand = 0.0;
_p_upperBand = _p_lowerBand = 0.0;
_len1 = Math.Max((Math.Log(Math.Sqrt(_period - 1)) / Math.Log(2.0)) + 2.0, 0);
_pow1 = Math.Max(_len1 - 2.0, 0.5);
_avoltyBuff.Clear();
_vsumBuff.Clear();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected override void ManageState(bool isNew)
{
if (isNew)
@@ -121,6 +118,23 @@ public class Jma : AbstractBase
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private double CalculateVolatility(double price, double del1, double del2)
{
double volty = System.Math.Max(System.Math.Abs(del1), System.Math.Abs(del2));
_vsumBuff.Add(volty, Input.IsNew);
_vSum += (_vsumBuff[^1] - _vsumBuff[0]) / _vsumBuff.Count;
_avoltyBuff.Add(_vSum, Input.IsNew);
return volty;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private double CalculateRelativeVolatility(double volty, double avgVolty)
{
double rvolty = (avgVolty > 0) ? volty / avgVolty : 1;
return System.Math.Min(System.Math.Max(rvolty, 1.0), System.Math.Pow(_len1, 1.0 / _pow1));
}
protected override double Calculation()
{
ManageState(Input.IsNew);
@@ -130,35 +144,30 @@ public class Jma : AbstractBase
{
_upperBand = _lowerBand = price;
_prevMa1 = _prevJma = price;
return price;
}
double del1 = price - _upperBand;
double del2 = price - _lowerBand;
double volty = Math.Max(Math.Abs(del1), Math.Abs(del2));
double volty = CalculateVolatility(price, del1, del2);
double avgVolty = _avoltyBuff.Average();
_vsumBuff.Add(volty, Input.IsNew);
_vSum += (_vsumBuff[^1] - _vsumBuff[0]) / _vsumBuff.Count;
_avoltyBuff.Add(_vSum, Input.IsNew);
double avgvolty = _avoltyBuff.Average();
double rvolty = (avgvolty > 0) ? volty / avgvolty : 1;
rvolty = Math.Min(Math.Max(rvolty, 1.0), Math.Pow(_len1, 1.0 / _pow1));
double pow2 = Math.Pow(rvolty, _pow1);
double Kv = Math.Pow(_beta, Math.Sqrt(pow2));
double rvolty = CalculateRelativeVolatility(volty, avgVolty);
double pow2 = System.Math.Pow(rvolty, _pow1);
double Kv = System.Math.Pow(_beta, System.Math.Sqrt(pow2));
_upperBand = (del1 >= 0) ? price : price - (Kv * del1);
_lowerBand = (del2 <= 0) ? price : price - (Kv * del2);
double _alpha = Math.Pow(_beta, pow2);
double ma1 = Input.Value + _alpha * (_prevMa1 - Input.Value);
double alpha = System.Math.Pow(_beta, pow2);
double ma1 = price + alpha * (_prevMa1 - price);
_prevMa1 = ma1;
double det0 = price + _beta * (_prevDet0 - price + ma1) - ma1;
_prevDet0 = det0;
double ma2 = ma1 + _phase * det0;
double det1 = ((ma2 - _prevJma) * (1 - _alpha) * (1 - _alpha)) + (_alpha * _alpha * _prevDet1);
double det1 = ((ma2 - _prevJma) * _oneMinusAlphaSquared) + (_alphaSquared * _prevDet1);
_prevDet1 = det1;
double jma = _prevJma + det1;
_prevJma = jma;