TASC magazine indicators

Code: Select all

Function: VAcc

// TASC NOVEMBER 2023
// VAcc Function
// Scott Cong

inputs:
	iLength( numericsimple ),
	iSmooth( numericsimple ),
	iReturnType( numericsimple );

Variables:
	Length( iLength ),
	Avg_acc( 0 ),
	Avg_vel( 0 ),
	Sum_acc( 0 ),
	Sum_vel( 0 ),
	Idx( 0 ),
	Result( 0 );

Sum_vel = 0;

for Idx = 1 to Length
begin
    Sum_vel += (Close - Close[Idx]) / Idx;
end;

Avg_vel = XAverage(Sum_vel / Length, iSmooth);

Sum_acc = 0;

for Idx = 1 to Length
begin
    Sum_acc += (Avg_vel - Avg_vel[Idx]) / Idx;
end;

Avg_acc = Sum_acc / Length;

if iReturnType = 0 then
    Result = Avg_vel
else
    Result = Sum_acc;

VAcc = Result;


Indicator: VAcc 

// TASC NOVEMBER 2023
// VAcc - Velocity (V) and Acceleration (Acc) 	
// Scott Cong

inputs:
	Period( 21 ),
	Smooth( 5 );

variables:
	AvgVel( 0 ),
	AvgAcc( 0 );

AvgVel = 100 * VAcc(Period, Smooth, 0);
AvgAcc = 100 * VAcc(Period, Smooth, 1);

Plot1( AvgVel / Period * 2, "VAcc" );
Plot2( 0, "Zero" );

Code: Select all

Function: Laguerre Filter
{
	TASC JUL 2025
	Laguerre Filter
	(C) 2002-2025 John F. Ehlers
}

inputs:
	Gama( .8 ),
	Length( 40 );

variables:
	L0( 0 ),
	L1( 0 ),
	L2( 0 ),
	L3( 0 ),
	L4( 0 ),
	Laguerre( 0 );
	
L0 = $UltimateSmoother(Close, Length);
L1 = -Gama * L0[1] + L0[1] + Gama * L1[1];
L2 = -Gama * L1[1] + L1[1] + Gama * L2[1];
L3 = -Gama * L2[1] + L2[1] + Gama * L3[1];
L4 = -Gama * L3[1] + L3[1] + Gama * L4[1];

Laguerre = (L0 + 4*L1 + 6*L2 + 4*L3 + L4) / 16;


Plot1( Laguerre );
Plot2( L0 );


Indicator: Laguerre Oscillator
{
	TASC JUL 2025
	Laguerre Oscillator
	(C) 2002-2025 John F. Ehlers
}

inputs:
	Gama( .5 ),
	Length( 30 );

variables:
	L0( 0 ),
	L1( 0 ),
	RMS( 0 ),
	LaguerreOsc( 0 );

L0 = $UltimateSmoother(Close, Length);
L1 = -Gama * L0 + L0[1] + Gama * L1[1];
RMS = $RMS(L0 - L1, 100);

if RMS <> 0 then 
	LaguerreOsc = (L0 - L1) / RMS;
	
Plot1( LaguerreOsc, "Laguerre Osc" );
Plot2( 0, "Zero Line" );

Function: $RMS
{
	RMS Function
	(C) 2015-2025 John F. Ehlers
}

inputs:
	Price( numericseries ),
	Length( numericsimple );

variables:
	SumSq( 0 ),
	count( 0 );

SumSq = 0;

for count = 0 to Length - 1 
begin
	SumSq = SumSq + Price[count] * Price[count];
end;

If SumSq <> 0 then 
	$RMS = SquareRoot(SumSq / Length);

Function: $SuperSmoother
{
	UltimateSmoother Function
	(C) 2004-2025 John F. Ehlers
}

inputs:
	Price( numericseries ),
	Period( numericsimple );
	
variables:
	a1( 0 ),
	b1( 0 ),
	c1( 0 ),
	c2( 0 ),
	c3( 0 ),
	US( 0 );
	
a1 = ExpValue(-1.414*3.14159 / Period);
b1 = 2 * a1 * Cosine(1.414*180 / Period);
c2 = b1;
c3 = -a1 * a1;
c1 = (1 + c2 - c3) / 4;

if CurrentBar >= 4 then 
 US = (1 - c1)*Price + (2 * c1 - c2) * Price[1] 
 - (c1 + c3) * Price[2] + c2*US[1] + c3 * US[2];
 
if CurrentBar < 4 then 
	US = Price;

$UltimateSmoother = US;

Code: Select all

{ TSM Moving Average : Moving average system
 Copyright 2025 P J Kaufman. All rights reserved. }
{ strategy (1 - 10) as follows:
1. Moving average
2. Average-off
3. Weighted moving average
4. Triangular moving average
5. Pivot point moving average
6. Standard deviation moving average
7. Moving median
8. Geometric moving average
9. Exponential moving average
10. Linear regression
}
 input: strategy(1), period(20), SDvalue(0.05), 
usefutures(false), longonly(false);
 vars: signal(0), psignal(0), trend(0), size(1), ix(0), INT 
middle(0), 
 value(0), SD(0), SDpercent(0), prod(0), root(0), 
 smooth(0), newprice(0), sumofprices(0), sumofweights(0), 
 INT start(0), stockinvestment(10000), futuresinvestment(25000),
 ATRper(20), equity(0), adate(" "), totalPL(0), 
NAV(100), 
 returns(0), cumreturn(0), todayPL(0), totalLong(0), totalShort(0);
array: pricearray[150](0), sortprices[150](0), sortedarray[150](0);
 
if usefutures then
 size = futuresinvestment/(Avgtruerange(ATRper
)*bigpointvalue)
 else
 size = stockinvestment/close;
// 1. Moving Average
if strategy = 1 then begin
 trend = average(close,period);
 end;
// 2. Average off
if strategy = 2 then begin
 If Currentbar = 1 then
 trend = average(close,period)
 else
 trend = ((period - 1)*trend[1] + close)/period;
 end;
// 3. Weighted moving average
if strategy = 3 then begin
 sumofprices = 0;
 sumofweights = 0;
 for ix = 0 to period - 1 begin
 sumofweights = sumofweights + ix + 1;
 sumofprices = sumofprices + (ix+1)*close[ix];
 end;
 trend = sumofprices/sumofweights;
 end;
// 4. Triangulation
if strategy = 4 then begin
 middle = period/2;
// increase weights towards middle
 sumofprices = 0;
 sumofweights = 0;
// prices increase towards middle
 for ix = 0 to middle begin
 sumofweights = sumofweights + ix + 1;
 sumofprices = sumofprices + (ix+1)*close[ix];
 end;
 value = 0;
 for ix = period to middle - 1 begin
 value = value + 1;
 sumofweights = sumofweights + value;
 sumofprices = sumofprices + value*close[ix];
 end;
 trend = sumofprices/sumofweights;
 end;
// 5. Pivot-Point moving average
if strategy = 5 then begin
 start = period - period/3;
 sumofprices = 0;
 sumofweights = 0;
 value = start + 1;
 for ix = 0 to period - 1 begin
 value = value - 1;
 sumofweights = sumofweights + value;
 sumofprices = sumofprices + value*close[ix];
 end;
 trend = sumofprices/sumofweights;
 end;
// 6. Standard deviation moving average
if strategy = 6 then begin
 SD = stddev(close,period);
 SDpercent = (SD - SD[1])/SD;
 trend = average(close,period) + 
SDvalue*SDpercent;
 end;
// 7. Moving median
if strategy = 7 then begin
// move prices to array
 for ix = 0 to period - 1 begin
 pricearray[ix + 1] = close[ix];
 end;
 value1 = sortarray(pricearray,period,1);
 trend = pricearray[period/2];
 end;
 // 8. Geometric moving average
if strategy = 8 then begin
 prod = 1;
 for ix = 0 to period - 1 begin
 prod = prod*close[ix];
 end;
 root = 1/period;
 trend = power(prod,root);
 end;
// 9. Exponential smoothing
if strategy = 9 then begin
 smooth = 2/(period + 1);
 trend = trend[1] + smooth*(close - trend[1]);
 end;
// 10. Linear regression, slope increasing or decreasing
if strategy = 10 then begin
 trend = linearregslope(close,period);
 if trend > 0 then begin
 buy to cover all shares next bar on open;
 buy size share next bar on open;
 signal = 1;
 end
 else if trend < 0 then begin
 sell all shares next bar on open;
 if longonly = false then begin
 sell short size share next bar on open;
 end;
 signal = -1;
 end;
 end;
// common entry code
if strategy <> 10 then begin
 if trend > trend[1] then signal = 1
 else if trend < trend[1] then signal = -1;
// new long position
 if psignal <= 0 and signal > 0 then begin
 buy to cover all shares next bar on open;
 buy size shares next bar on open;
 end
 else if psignal > 0 and signal < 0 then begin
 sell all shares next bar on open;
 if longonly = false then begin
 sell short size shares next bar on 
open; 
 end;
 end;
 end;
psignal = signal;
 equity = netprofit + openpositionprofit;
todayPL = equity - equity[1];
if psignal > 0 then
 totalLong = totalLong + todayPL
 else if psignal < 0 then
 totalShort = totalShort + todayPL;
totalPL = totalPL + equity - equity[1];
returns = (equity - equity[1])/stockinvestment;
cumreturn = cumreturn + returns;
if usefutures = false then
 NAV = 100
 else
 NAV = NAV[1]*(1 + returns);
 
adate = ELdatetostring(date);
 If Currentbar = 1 then print(file("c:\TradeStation\
Smoothing.csv"), 
 "Date,Close,Signal,Size,TotalShort,TotalLong,To
talPL,Returns,CumReturn,NAV");
 print(file("c:\TradeStation\Smoothing.csv"),adate, ",", 
close:8:6, ",", 
 signal:5:0, ",", size:8:3, ",", totalShort:8:0, ",", totalLong:8:0, ",", 
 totalPL:8:0, ",", returns:6:4, ",", cumreturn:8:4, ",", 
NAV:9:4);

Code: Select all

{
	TASC JUNE 2026
	One Percent A Week: A High-Probability Weekly 
	Trading Strategy For TQQQ
	Part 2: Variations And Community Enhancements
	Dion Kurczek
}

inputs:
	FirstDayStrengthPct( 2.0 ),
	NextDayWeakPct( 3.0 ),
	TargetMult( 1.07 ),
	ExpansionTriggerPct( 0.3 ),
	ExpansionMult( 1.011 ),
	RecoveryExitMult( 1.025 ),
	LossArmPct( -1.3 ),
	HardLossMult( 0.985 );

variables:
	DayOfTradeWeek( 0 ),
	EntryDayOfTradeWeek( 0 ),
	ProfitPct( 0 ),
	TargetPrice( 0 ),
	FirstDayStrong( false ),
	MP( 0 );

MP = MarketPosition;

if CurrentBar = 1 then
begin
	DayOfTradeWeek = 1;
	EntryDayOfTradeWeek = 0;
	FirstDayStrong = false;
end
else
begin
	if DayOfWeek( Date ) < DayOfWeek( Date[1] ) then
	begin
		DayOfTradeWeek = 1;
		EntryDayOfTradeWeek = 0;
		FirstDayStrong = false;
	end
	else if Date <> Date[1] then
		DayOfTradeWeek = DayOfTradeWeek[1] + 1
	else
		DayOfTradeWeek = DayOfTradeWeek[1];
end;

if MP = 0 and DayOfWeek( Date ) <> 1 
 and DayOfWeek( Date Next Bar ) = 1 then
begin
	Buy ( "WeekIn" ) next bar at market;
end
else if MP = 1 then
begin
	if MP[1] <> 1 then
	begin
		EntryDayOfTradeWeek = DayOfTradeWeek;
		FirstDayStrong = false;
	end;

	ProfitPct = 100 * ( ( Close / EntryPrice ) - 1 );

	if DayOfTradeWeek = EntryDayOfTradeWeek 
	 and ProfitPct > FirstDayStrengthPct then
		FirstDayStrong = true;

	if DayOfTradeWeek = EntryDayOfTradeWeek + 1 and
	   FirstDayStrong and
	   ProfitPct < NextDayWeakPct then
		Sell ( "MomFail" ) next bar at market
	else if ProfitPct <= LossArmPct then
		Sell ( "HardLoss" ) next bar 
		 at EntryPrice * HardLossMult stop
	else if ProfitPct > 0 then
	begin
		TargetPrice = EntryPrice * TargetMult;

		if ProfitPct > ExpansionTriggerPct then
			TargetPrice = TargetPrice * ExpansionMult;

		Sell ( "Target" ) next bar at TargetPrice limit;
	end
	else if DayOfTradeWeek > EntryDayOfTradeWeek 
	 and Close < Open then
		Sell ( "Recovery" ) next bar 
		 at EntryPrice * RecoveryExitMult limit
	else if DayOfTradeWeek > EntryDayOfTradeWeek then
		Sell ( "BrkEven" ) next bar at EntryPrice limit;

	if DayOfWeek( Date ) = 5 then
		SetExitOnClose;
end;

Code: Select all

Function: UniXMA

{*******************************************************
TASC NOV 2026
Description : UniXMA Function
Provided By : (C) 2011-2026 Igor Durkin, trendlaboratory.net
*******************************************************}

inputs: 
	price( numericseries ),
	length( numericsimple ),
	poles( numericsimple ),
	order( NumericSimple ),
	wf( numericsimple ),
	df( NumericSimple );

variables: 
	alpha(0), 
	bet(0), 
	k(0), 
	j(0), 
	uniema(0), 
	uni_size(0);

arrays: 
	uniema_tmp[](0);
{ calculate alpha once—lag is preserved across all Order 
values }
once 
begin
	alpha = wf*order / (length + wf*order - 1);
	bet = 1 - alpha;
	uni_size = poles * order;
	Array_SetMaxIndex( uniema_tmp, uni_size - 1 );
end;

uniema = price;

if currentbar >= 1 then 
begin
 { outer loop—Order passes }
 for k=0 to order-1 
 begin
 	{ inner loop—Poles correction }
 	for j=0 to poles-1 
 	begin
 		{ initialise filter state at first call }
 		if currentbar = 1 then
 			uniema_tmp[poles*k+j] = price
 		else 
 		begin
 			uniema_tmp[poles*k+j] = bet 
 			 * uniema_tmp[poles*k+j][1] 
 			 + alpha * uniema; 
 			if j > 0 then
 				uniema = uniema 
 				 + df 
 				 * (uniema_tmp[poles*k] 
 				 - uniema_tmp[poles*k+j])
 			else
 				uniema = uniema_tmp[poles*k+j];
 			end;
 		end;
	end;
end;

UniXMA = uniema;


Function: UniXMA_arr

{*******************************************************
TASC NOV 2026
Description : UniXMA_arr Function
Provided By : (C) 2011-2026 Igor Durkin, trendlaboratory.net
*******************************************************}

inputs: 
	price( numericseries ),
	length( numericsimple ),
	poles( numericsimple ),
	order( numericsimple ),
	wf( numericsimple ),
	df( numericsimple ),
	outarray[n]( numericarrayref );

variables: 
	alpha( 0 ), 
	bet( 0 ), 
	k( 0 ), 
	j( 0 ), 
	uniema( 0 ), 
	uni_size( 0 );
	
arrays: 
	uniema_tmp[]( 0 );
{ calculate alpha once—lag is preserved across all Order
values }
once 
begin
	alpha = wf * order / (length + wf * order - 1);
	bet = 1 - alpha;
	uni_size = poles*order;
 	Array_SetMaxIndex(uniema_tmp, uni_size-1);
end;

uniema = price;

if currentbar >= 1 then 
begin
 { outer loop—Order passes }
	for k=0 to order-1 
 	begin
 		{ inner loop—Poles correction }
 		for j=0 to poles-1 begin
 			{ initialise filter state at first call }
 			if currentbar = 1 then
 				uniema_tmp[poles*k+j] = price
 			else 
 			begin
 				uniema_tmp[poles*k+j] = bet
 		 	 	 * uniema_tmp[poles*k+j][1] + alpha * uniema;
 				if j > 0 then
 				uniema = uniema + df*(uniema_tmp[poles*k]
		 	 	- uniema_tmp[poles*k+j])
 				else
					uniema = uniema_tmp[poles*k+j];
			end;
		end;
 		outarray[k] = uniema;
 	end;
end;

UniXMA_arr = uniema;


Indicator: UniEMA

{*******************************************************
TASC NOV 2026
Description : This Indicator plots UniEMA
Provided By : (C) 2011-2026 Igor Durkin, trendlaboratory.net
*******************************************************}

inputs: 
	double Price( Close), // Applied to
	int Length( 14 ), // Period
	int Poles( 2 ), // Poles: 1-EMA, 2-DEMA, 3-TEMA, 4-QEMA
	int Order( 3 ), // Smoothing Order (min. 1)
	double WeightFactor( 2 ), // (Wilder=1,EMA=2)
	double DampingFactor( 0.5 ), // Damping Factor (ex. 0.7)
	int Displace( 0 ), // Displace in bars
	bool ShowColorLine( true ), // Show Color Line
	int UpTrendColor( blue ), // UpTrend Color
	int DnTrendColor( red ), // DownTrend Color
	int ColorBarsBack( 1 ); // Color Bars Back (0 or 1)
	
variable: 
	UniEMA( 0 ), 
	trend( 0 );
	
if Displace >= 0 or CurrentBar > AbsValue(Displace) then
begin
	UniEMA = UniXMA(Price, Length, Poles, Order,
	 WeightFactor, DampingFactor);
 	
 	Plot1[Displace]( UniEMA,"UniEMA" );
 	
 	if ShowColorLine then 
 	begin
 		trend = trend[1];
 		
 		if UniEMA > UniEMA[1] then trend = 1;
 		
 		if UniEMA < UniEMA[1] then trend = -1;
 		
 		if trend > 0 then 
 			SetPlotColor[Displace + ColorBarsBack]
 			 (1, UpTrendColor);
 		if trend < 0 then
 			SetPlotColor[Displace + ColorBarsBack]
 		 	(1, DnTrendColor);
 	end;
 		
 	if Displace <= 0 then 
 	begin
 		if Price > UniEMA and UniEMA > UniEMA[1] 
 		and UniEMA[1] <= UniEMA[2] then
			Alert( "Indicator turning up" )
		else if Price < UniEMA and UniEMA < UniEMA[1] 
		 and UniEMA[1] >= UniEMA[2] then
 			Alert( "Indicator turning down" );
 	end;
end;


Indicator: UniEMA Cascade

{*******************************************************
TASC NOV 2026
Description : This Indicator plots UniEMA Cascade
Provided By : (C) 2011-2026 Igor Durkin, trendlaboratory.net
*******************************************************}

inputs: 
	double Price( Close ), 		// Applied to
	int Length( 14), 			// Period
	int Poles( 1 ), 			// Poles (min. 1)
	int Order( 20 ), 			// Smoothing Order (min. 1)
	double WeightFactor( 2 ), 	// (Wilder=1,EMA=2)
	double DampingFactor( 0 ), 	// Damping Factor
	int UpTrendColor( Green ), 	// UpTrend Color
	int DnTrendColor( Red ); 	// DownTrend Color

variables: 
	int k( 0 ), 
	double UniEMA( 0 );

array: 
	smooths[](0), 
	trend[](0);

once 
begin
	Array_SetMaxIndex( smooths, Order - 1 );
	Array_SetMaxIndex( trend, Order - 1 );
end;

if CurrentBar > 1 then 
begin
	UniEMA = UniXMA_arr( Price, Length, Poles, Order,
	 WeightFactor, DampingFactor, smooths);

	for k = 0 to Order-1 
	begin
		trend[k] = trend[k][1];
		
		if smooths[k] > smooths[k][1] then 
			trend[k] = 1;
		if smooths[k] < smooths[k][1] then 
			trend[k] = -1;

		switch(k) 
		begin
			case 0: Plot1( smooths[k],"Order #1" );
			case 1: Plot2( smooths[k],"Order #2" );
			case 2: Plot3( smooths[k],"Order #3" );
			case 3: Plot4( smooths[k],"Order #4" );
			case 4: Plot5( smooths[k],"Order #5" );
			case 5: Plot6( smooths[k],"Order #6" );
			case 6: Plot7( smooths[k],"Order #7" );
			case 7: Plot8( smooths[k],"Order #8" );
			case 8: Plot9( smooths[k],"Order #9" );
			case 9: Plot10( smooths[k],"Order #10" );
			case 10: Plot11( smooths[k],"Order #11" );
			case 11: Plot12( smooths[k],"Order #12" );
			case 12: Plot13( smooths[k],"Order #13" );
			case 13: Plot14( smooths[k],"Order #14" );
			case 14: Plot15( smooths[k],"Order #15" );
			case 15: Plot16( smooths[k],"Order #16" );
			case 16: Plot17( smooths[k],"Order #17" );
			case 17: Plot18( smooths[k],"Order #18" );
			case 18: Plot19( smooths[k],"Order #19" );
			case 19: Plot20( smooths[k],"Order #20" );
		end;
		
		if trend[k] > 0 then 
			SetPlotColor[1]( k + 1, UpTrendColor)
		else 
			SetPlotColor[1]( k + 1, DnTrendColor);
	end;
end;