ANN BTC MTF Golden Cross Period MACD

Noldo · study · 783 行 · 点赞 386 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Noldo
 
//@version=4
study("ANN BTC MTF Golden Cross Period MACD" , overlay = true , max_bars_back = 1)
src = close[0]
 
// Definition : INDICATORS
 
// RSI
 
_rsi = rsi(close,14)
 
// MACD
 
fun_macd(_src,_fastlen,_slowlen,_signallen) =>
 
    float _output = na 
    _macd   = ema(_src,_fastlen) - ema(_src,_slowlen)
    _signal = ema(_macd , _signallen)
    _output := _macd - _signal
 
 
_hist = fun_macd(src,12,26,9)
 
// MOMENTUM
 
t_mom = 10
 
 
f_mom(_src , _length) =>
 
    _output = 0.00
    _length_adjusted = _length < 0 ? 0 : _length
 
    _output := nz((_src / _src[_length_adjusted] ) - 1 ) * 100   
 
 
mom = f_mom(src , t_mom)
 
// BOLLINGER BANDS 
 
length = 20
mult = 2.0
basis = sma(src, length)
dev = mult * stdev(src, length)
upper = basis + dev
lower = basis - dev
 
 
// CM GUPPY EMA 
 
len1 = 3
len2 = 5
len3 = 8
len4 = 10
len5 = 12
len6 = 15
//Slow EMA
len7 = 30
len8 = 35
len9 = 40
len10 = 45
len11 = 50
len12 = 60
 
 
//Fast EMA
ema1 = ema(src, len1)
ema2 = ema(src, len2)
ema3 = ema(src, len3)
ema4 = ema(src, len4)
ema5 = ema(src, len5)
ema6 = ema(src, len6)
//Slow EMA
ema7 = ema(src, len7)
ema8 = ema(src, len8)
ema9 = ema(src, len9)
ema10 = ema(src, len10)
ema11 = ema(src, len11)
ema12 = ema(src, len12)
// DEEP LEARNING INDICATORS
 
_indicator1 = ((_rsi - _rsi[1] ) / (_rsi[1]))
_indicator2 = ((volume - volume[1] ) / (volume[1]))
_indicator3 = ((_hist - _hist[1] ) / (_hist[1]))
_indicator4 = ((mom - mom[1] ) / (mom[1]))
_indicator5 = ((lower - lower[1] ) / (lower[1]))
_indicator6 = ((basis - basis[1] ) / (basis[1]))
_indicator7 = ((upper - upper[1] ) / (upper[1]))
 
_indicator8  = ((ema1 - ema1[1] ) / (ema1[1]))
_indicator9  = ((ema2 - ema2[1] ) / (ema2[1]))
_indicator10 = ((ema3 - ema3[1] ) / (ema3[1]))
_indicator11 = ((ema4 - ema4[1] ) / (ema4[1]))
_indicator12 = ((ema5 - ema5[1] ) / (ema5[1]))
_indicator13 = ((ema6 - ema6[1] ) / (ema6[1]))
_indicator14 = ((ema7 - ema7[1] ) / (ema7[1]))
_indicator15 = ((ema8 - ema8[1] ) / (ema8[1]))
_indicator16 = ((ema9 - ema9[1] ) / (ema9[1]))
_indicator17 = ((ema10 - ema10[1] ) / (ema10[1]))
_indicator18 = ((ema11 - ema11[1] ) / (ema11[1]))
_indicator19 = ((ema12 - ema12[1] ) / (ema12[1]))
 
// Inputs on Tangent Function : 
 
tangentdiff(_src) => nz((_src - _src[1]) / _src[1] ) 
 
 
// Deep Learning Activation Function (Tanh) : 
 
ActivationFunctionTanh(v) => (1 - exp(-2 * v))/( 1 + exp(-2 * v))
 
 
// DEEP LEARNING 
 
// INPUTS : 
 
input_1 = tangentdiff(_indicator1)
input_2 = tangentdiff(_indicator2)
input_3 = tangentdiff(_indicator3)
input_4 = tangentdiff(_indicator4)
input_5 = tangentdiff(_indicator5)
input_6 = tangentdiff(_indicator6)
input_7 = tangentdiff(_indicator7)
input_8 = tangentdiff(_indicator8)
input_9 = tangentdiff(_indicator9)
input_10 = tangentdiff(_indicator10)
input_11 = tangentdiff(_indicator11)
input_12 = tangentdiff(_indicator12)
input_13 = tangentdiff(_indicator13)
input_14 = tangentdiff(_indicator14)
input_15 = tangentdiff(_indicator15)
input_16 = tangentdiff(_indicator16)
input_17 = tangentdiff(_indicator17)
input_18 = tangentdiff(_indicator18)
input_19 = tangentdiff(_indicator19)
 
 
// LAYERS : 
 
// Input Layers 
 
n_0 = ActivationFunctionTanh(input_1 + 0)   
n_1 = ActivationFunctionTanh(input_2 + 0) 
n_2 = ActivationFunctionTanh(input_3 + 0) 
n_3 = ActivationFunctionTanh(input_4 + 0) 
n_4 = ActivationFunctionTanh(input_5 + 0)
n_5 = ActivationFunctionTanh(input_6 + 0)
n_6 = ActivationFunctionTanh(input_7 + 0)
n_7 = ActivationFunctionTanh(input_8 + 0)
n_8 = ActivationFunctionTanh(input_9 + 0)
n_9 = ActivationFunctionTanh(input_10 + 0)
n_10 = ActivationFunctionTanh(input_11 + 0)
n_11 = ActivationFunctionTanh(input_12 + 0)
n_12 = ActivationFunctionTanh(input_13 + 0)
n_13 = ActivationFunctionTanh(input_14 + 0)
n_14 = ActivationFunctionTanh(input_15 + 0)
n_15 = ActivationFunctionTanh(input_16 + 0)
n_16 = ActivationFunctionTanh(input_17 + 0)
n_17 = ActivationFunctionTanh(input_18 + 0)
n_18 = ActivationFunctionTanh(input_19 + 0)
 
 
//
 
// BTC 1 Minute
 
fun_btc1() => 
 
    float _output = na 
 
    n_19 = ActivationFunctionTanh(0.001035  * n_0  + -0.000547  * n_1  + 0.002711  * n_2  + 0.002422   * n_3  + 0.000514  * n_4  + -0.003417  * n_5  + 
                                 -0.000103  * n_6  + 0.004029   * n_7  + 0.003805  * n_8  + 0.003190   * n_9  + 0.002755  * n_10 + 0.002324   * n_11 + 
                                  0.001708  * n_12 + -0.000654  * n_13 + -0.001226 * n_14 + -0.001723  * n_15 + -0.002161 * n_16 + -0.002550  * n_17 + 
                                 -0.003215  * n_18 + 0.262654 ) 
 
    n_20 = ActivationFunctionTanh(0.000871  * n_0  + -0.000464  * n_1  + 0.002263  * n_2  + 0.002004  * n_3  + 0.000395   * n_4  + -0.002937  * n_5  + 
                                 -0.000110  * n_6  + 0.003381   * n_7  + 0.003192  * n_8  + 0.002672  * n_9  + 0.002304   * n_10 + 0.001938   * n_11 + 
                                  0.001415  * n_12 + -0.000587  * n_13 + -0.001072 * n_14 + -0.001493 * n_15 + -0.001864  * n_16 + -0.002194  * n_17 + 
                                 -0.002757  * n_18 + -0.115754 ) 
 
    n_21 = ActivationFunctionTanh(0.000748   * n_0  + -0.000400 * n_1  + 0.001938   * n_2  + 0.001711  * n_3  + 0.000326   * n_4  + -0.002545  * n_5  + 
                                 -0.000102   * n_6  + 0.002903  * n_7  + 0.002740   * n_8  + 0.002292  * n_9  + 0.001974   * n_10 + 0.001659   * n_11 + 
                                  0.001208   * n_12 + -0.000517 * n_13 + -0.000935  * n_14 + -0.001298 * n_15 + -0.001618  * n_16 + -0.001902  * n_17 + 
                                 -0.002387   * n_18 + -0.339950 ) 
 
    n_22 = ActivationFunctionTanh(0.000695  * n_0  + -0.000372 * n_1  + 0.001799  * n_2  + 0.001587  * n_3  + 0.000300   * n_4  + -0.002370  * n_5  + 
                                 -0.000097  * n_6  + 0.002696  * n_7  + 0.002545  * n_8  + 0.002129  * n_9  + 0.001833   * n_10 +  0.001540  * n_11 + 
                                 0.001121   * n_12 + -0.000484 * n_13 + -0.000872 * n_14 + -0.001210 * n_15 + -0.001507  * n_16 + -0.001772  * n_17 + 
                                 -0.002223  * n_18 + -0.432853 ) 
 
    n_23 = ActivationFunctionTanh(0.000993  * n_0  + -0.000526  * n_1  + 0.002595  * n_2  + 0.002312  * n_3  + 0.000479   * n_4  + -0.003303   * n_5  + 
                                 -0.000107  * n_6  + 0.003863   * n_7  + 0.003648  * n_8  + 0.003057  * n_9  + 0.002639   * n_10 + 0.002224    * n_11 + 
                                  0.001631  * n_12 + -0.000641  * n_13 + -0.001192 * n_14 + -0.001670 * n_15 + -0.002091  * n_16 + -0.002466   * n_17 + 
                                 -0.003105  * n_18 + 0.148192 ) 
 
    n_24 = ActivationFunctionTanh(0.000916  * n_0  + -0.000487  * n_1  + 0.002384  * n_2  + 0.002116  * n_3  + 0.000423   * n_4  + -0.003076  * n_5  + 
                                 -0.000110  * n_6  + 0.003559   * n_7  + 0.003360  * n_8  + 0.002814  * n_9  + 0.002426   * n_10 + 0.002042   * n_11 + 
                                  0.001493  * n_12 + -0.000609  * n_13 + -0.001118 * n_14 + -0.001561 * n_15 + -0.001951  * n_16 + -0.002297  * n_17 + 
                                 -0.002889  * n_18 + -0.025859 )
                               
    _output := ActivationFunctionTanh( 0.199872 * n_19  + 0.166532  * n_20  + 0.147040 * n_21  + 0.139158 * n_22  + 0.189832  * n_23  + 0.174459  * n_24  + 
                                      0.232677 ) 
 
 
// BTC 3 Minutes
 
fun_btc3() => 
 
    float _output = na 
    
    n_19 = ActivationFunctionTanh(0.002123  * n_0  + 0.000026   * n_1  + 0.000552  * n_2  + 0.000803  * n_3  + 0.001434   * n_4  + -0.000310  * n_5  + 
                                  0.000631  * n_6  + 0.002397   * n_7  + 0.001834  * n_8  + 0.001168  * n_9  + 0.000800   * n_10 + 0.000470   * n_11 + 
                                  0.000018  * n_12 + -0.001559  * n_13 + -0.001780 * n_14 + -0.001986 * n_15 + -0.002121  * n_16 + -0.002148  * n_17 + 
                                 -0.002187  * n_18 + 0.460544 ) 
 
 
    n_20 = ActivationFunctionTanh(0.001727  * n_0  + 0.000021   * n_1  + 0.000447  * n_2  + 0.000648  * n_3  + 0.001158   * n_4  + -0.000266  * n_5  + 
                                  0.000505  * n_6  + 0.001945   * n_7  + 0.001486  * n_8  + 0.000942  * n_9  + 0.000642   * n_10 + 0.000372   * n_11 + 
                                  0.000004  * n_12 + -0.001284  * n_13 + -0.001465 * n_14 + -0.001633 * n_15 + -0.001744  * n_16 + -0.001766  * n_17 + 
                                 -0.001799  * n_18 + -0.099424 ) 
 
 
    n_21 = ActivationFunctionTanh(0.001538  * n_0  + 0.000019  * n_1  + 0.000397  * n_2  + 0.000577  * n_3  + 0.001030  * n_4  + -0.000239  * n_5  + 
                                  0.000448  * n_6  + 0.001731  * n_7  + 0.001322  * n_8  + 0.000838  * n_9  + 0.000570  * n_10 + 0.000330   * n_11 + 
                                  0.000001  * n_12 + -0.001147 * n_13 + -0.001308 * n_14 + -0.001458 * n_15 + -0.001557 * n_16 + -0.001577  * n_17 + 
                                 -0.001606  * n_18 + -0.279473 ) 
 
    n_22 = ActivationFunctionTanh(0.002007 * n_0  + 0.000025   * n_1  + 0.000520  * n_2  + 0.000757  * n_3  + 0.001351   * n_4  + -0.000300  * n_5  + 
                                  0.000592 * n_6  + 0.002263   * n_7  + 0.001731  * n_8  + 0.001100  * n_9  + 0.000752   * n_10 +  0.000439  * n_11 + 
                                  0.000012 * n_12 + -0.001482  * n_13 + -0.001692 * n_14 + -0.001886 * n_15 + -0.002014  * n_16 + -0.002040  * n_17 + 
                                 -0.002078 * n_18 + 0.232250 ) 
 
    n_23 = ActivationFunctionTanh(0.001901  * n_0  + 0.000024   * n_1  + 0.000492  * n_2  + 0.000715  * n_3  + 0.001278   * n_4  + -0.000288   * n_5  + 
                                  0.000559  * n_6  + 0.002142   * n_7  + 0.001637  * n_8  + 0.001040  * n_9  + 0.000710   * n_10 + 0.000413    * n_11 + 
                                  0.000008  * n_12 + -0.001408  * n_13 + -0.001607 * n_14 + -0.001792 * n_15 + -0.001913  * n_16 + -0.001938   * n_17 + 
                                 -0.001974  * n_18 + 0.090036 )
                               
    n_24 = ActivationFunctionTanh(0.001751  * n_0  + 0.000022   * n_1  + 0.000453  * n_2  + 0.000657  * n_3  + 0.001174   * n_4  + -0.000269  * n_5  + 
                                  0.000512  * n_6  + 0.001971   * n_7  + 0.001506  * n_8  + 0.000955  * n_9  + 0.000651   * n_10 + 0.000378   * n_11 + 
                                  0.000004  * n_12 + -0.001301  * n_13 + -0.001484 * n_14 + -0.001655 * n_15 + -0.001767  * n_16 + -0.001789  * n_17 + 
                                 -0.001823  * n_18 + -0.075800 )
                                 
    n_25 = ActivationFunctionTanh(0.001777  * n_0  + 0.000022   * n_1  + 0.000460  * n_2  + 0.000668  * n_3  + 0.001193   * n_4  + -0.000272  * n_5  + 
                                  0.000520  * n_6  + 0.002002   * n_7  + 0.001529  * n_8  + 0.000970  * n_9  + 0.000661   * n_10 + 0.000384   * n_11 + 
                                  0.000005  * n_12 + -0.001320  * n_13 + -0.001506 * n_14 + -0.001679 * n_15 + -0.001793  * n_16 + -0.001816  * n_17 + 
                                 -0.001850  * n_18 + -0.048113 ) 
 
    n_26 = ActivationFunctionTanh(0.001304  * n_0  + 0.000016   * n_1  + 0.000336  * n_2  + 0.000488  * n_3  + 0.000872   * n_4  + -0.000205  * n_5  + 
                                  0.000379  * n_6  + 0.001467   * n_7  + 0.001120  * n_8  + 0.000709  * n_9  + 0.000482   * n_10 + 0.000278   * n_11 + 
                                 -0.000000  * n_12 + -0.000974  * n_13 + -0.001111 * n_14 + -0.001238 * n_15 + -0.001322  * n_16 + -0.001339  * n_17 + 
                                 -0.001364  * n_18 + -0.490012 ) 
 
    _output := ActivationFunctionTanh(0.161390 * n_19  + 0.125042   * n_20  + 0.113319 * n_21  + 0.146797 * n_22  + 0.137496 * n_23  + 0.126592 * n_24  + 
                                      0.128412 * n_25  + 0.099997   * n_26  + -0.031189 )
 
 
// BTC 5 Minutes
 
 
fun_btc5() => 
 
    float _output = na 
    
    n_19 = ActivationFunctionTanh(0.006017  * n_0  + -0.000133  * n_1  + 0.003973  * n_2  + 0.000452  * n_3  + 0.001212   * n_4  + -0.002359  * n_5  + 
                                  0.002415  * n_6  + 0.005932   * n_7  + 0.003877  * n_8  + 0.001921  * n_9  + 0.000979   * n_10 +  0.000298  * n_11 + 
                                 -0.000395  * n_12 + -0.002463  * n_13 + -0.002613 * n_14 + -0.002726 * n_15 + -0.002816  * n_16 + -0.002890  * n_17 + 
                                 -0.003013  * n_18 + 0.431206 ) 
 
 
    n_20 = ActivationFunctionTanh(0.004061  * n_0  + -0.000090  * n_1  + 0.002641  * n_2  + 0.000305  * n_3  + 0.000794   * n_4  + -0.001673  * n_5  + 
                                  0.001568  * n_6  + 0.003965   * n_7  + 0.002573  * n_8  + 0.001245  * n_9  + 0.000606   * n_10 + 0.000143   * n_11 + 
                                 -0.000328  * n_12 + -0.001734  * n_13 + -0.001837 * n_14 + -0.001914 * n_15 + -0.001975  * n_16 + -0.002027  * n_17 + 
                                 -0.002111  * n_18 + -0.382686 ) 
 
 
    n_21 = ActivationFunctionTanh(0.005755  * n_0  + -0.000127 * n_1  + 0.003784  * n_2  + 0.000432  * n_3  + 0.001150  * n_4  + -0.002287  * n_5  + 
                                  0.002285  * n_6  + 0.005658  * n_7  + 0.003691  * n_8  + 0.001817  * n_9  + 0.000915  * n_10 +  0.000262  * n_11 + 
                                 -0.000401  * n_12 + -0.002383 * n_13 + -0.002528 * n_14 + -0.002636 * n_15 + -0.002722 * n_16 + -0.002794  * n_17 + 
                                 -0.002911  * n_18 + 0.252004 ) 
 
    n_22 = ActivationFunctionTanh(0.005446 * n_0  + -0.000121  * n_1  + 0.003570  * n_2  + 0.000409  * n_3  + 0.001081   * n_4  + -0.002188  * n_5  + 
                                  0.002145 * n_6  + 0.005344   * n_7  + 0.003481  * n_8  + 0.001705  * n_9  + 0.000850   * n_10 +  0.000231  * n_11 + 
                                 -0.000398 * n_12 + -0.002276  * n_13 + -0.002413 * n_14 + -0.002516 * n_15 + -0.002598  * n_16 + -0.002666  * n_17 + 
                                 -0.002778 * n_18 + 0.102695 ) 
 
    n_23 = ActivationFunctionTanh(0.004542  * n_0  + -0.000101  * n_1  + 0.002960  * n_2  + 0.000341  * n_3  + 0.000891   * n_4  + -0.001861   * n_5  + 
                                  0.001762  * n_6  + 0.004441   * n_7  + 0.002884  * n_8  + 0.001399  * n_9  + 0.000685   * n_10 + 0.000167    * n_11 + 
                                 -0.000359  * n_12 + -0.001929  * n_13 + -0.002044 * n_14 + -0.002131 * n_15 + -0.002199  * n_16 + -0.002256   * n_17 + 
                                 -0.002350  * n_18 + -0.228588 )
                               
    n_24 = ActivationFunctionTanh(0.005623  * n_0  + -0.000124  * n_1  + 0.003692  * n_2  + 0.000422  * n_3  + 0.001120   * n_4  + -0.002246  * n_5  + 
                                  0.002224  * n_6  + 0.005523   * n_7  + 0.003601  * n_8  + 0.001768  * n_9  + 0.000886   * n_10 +  0.000248  * n_11 + 
                                 -0.000401  * n_12 + -0.002339  * n_13 + -0.002480 * n_14 + -0.002586 * n_15 + -0.002670  * n_16 + -0.002740  * n_17 + 
                                 -0.002855  * n_18 + 0.183601 )
                                 
    n_25 = ActivationFunctionTanh(0.004981  * n_0  + -0.000110  * n_1  + 0.003253  * n_2  + 0.000374  * n_3  + 0.000982   * n_4  + -0.002025  * n_5  + 
                                  0.001944  * n_6  + 0.004877   * n_7  + 0.003171  * n_8  + 0.001544  * n_9  + 0.000761   * n_10 + 0.000195   * n_11 + 
                                 -0.000381  * n_12 + -0.002102  * n_13 + -0.002228 * n_14 + -0.002322 * n_15 + -0.002397  * n_16 + -0.002460  * n_17 + 
                                 -0.002562  * n_18 + -0.078775 ) 
 
 
    _output := ActivationFunctionTanh(0.262383 * n_19  + 0.175495   * n_20  + 0.243476 * n_21  + 0.227423 * n_22  + 0.191729 * n_23  + 0.236145 * n_24  + 
                                      0.207806 * n_25  + 0.026324 )
 
// BTC 15 MINS 
 
fun_btc15() => 
 
    float _output = na 
    
    n_19 = ActivationFunctionTanh(1.293257  * n_0  + 0.472554   * n_1  + -0.895507 * n_2  + 7.015572  * n_3  + 0.593760   * n_4  + -1.305593  * n_5  + 
                                  0.004794  * n_6  + 2.186163   * n_7  + -0.179762 * n_8  +-1.225158  * n_9  + -0.977530  * n_10 + -0.462584  * n_11 + 
                                  0.408550  * n_12 + 1.769293   * n_13 + 1.192573  * n_14 + 0.363880  * n_15 + -0.614220  * n_16 + -1.674585  * n_17 + 
                                 -3.886520  * n_18 + 1.707623 ) 
 
 
    n_20 = ActivationFunctionTanh(-0.418554 * n_0  + -0.181308  * n_1  + 0.600509  * n_2  + 0.039391  * n_3  + -0.413697  * n_4  + -0.499073  * n_5  + 
                                 -0.261308  * n_6  + -0.232663  * n_7  + -0.351711 * n_8  + -0.378750 * n_9  + -0.322916  * n_10 + -0.256092  * n_11 + 
                                  -0.166355 * n_12 + -0.211169  * n_13 + -0.355281 * n_14 + -0.526071 * n_15 + -0.711899  * n_16 + -0.905197  * n_17 + 
                                 -1.296504  * n_18 + -0.554952 ) 
 
 
    n_21 = ActivationFunctionTanh(-0.035480 * n_0  + -0.021081 * n_1  + -0.365212 * n_2  + 0.056914  * n_3  + -0.142554 * n_4  + -0.059345  * n_5  + 
                                 -0.277609  * n_6  + -0.176719 * n_7  + -0.186312 * n_8  + -0.160749 * n_9  + -0.139131 * n_10 + -0.124488  * n_11 + 
                                 -0.115378  * n_12 + -0.208219 * n_13 + -0.251116 * n_14 + -0.289558 * n_15 + -0.323317 * n_16 + -0.352714  * n_17 + 
                                 -0.400455  * n_18 + -0.805595 ) 
 
    n_22 = ActivationFunctionTanh(0.127697 * n_0  + -0.396088  * n_1  + -0.220907 * n_2  + 0.373565  * n_3  + 0.099899   * n_4  +  0.854134  * n_5  + 
                                 -0.213292 * n_6  + 0.441236   * n_7  + -0.620463 * n_8  + -0.749920 * n_9  + -0.280333  * n_10 +  0.322233  * n_11 + 
                                  1.223385 * n_12 + 2.472768   * n_13 +  1.882159 * n_14 + 1.058183  * n_15 + 0.089279   * n_16 + -0.965008  * n_17 + 
                                 -3.185136 * n_18 + -1.527580 ) 
 
    n_23 = ActivationFunctionTanh(-0.332919 * n_0  + -0.354824  * n_1  + 0.467307  * n_2  + 0.075305  * n_3  + 0.216661   * n_4  + 0.341631    * n_5  + 
                                 -0.459070  * n_6  + 0.035533   * n_7  +-0.456678  * n_8  +-0.461727  * n_9  +-0.177285   * n_10 + 0.167962    * n_11 + 
                                  0.666441  * n_12 + 1.196486   * n_13 + 0.798169  * n_14 + 0.270911  * n_15 + -0.335477  * n_16 + -0.987666   * n_17 + 
                                 -2.348907  * n_18 + -1.126590 )
                               
    n_24 = ActivationFunctionTanh(-0.435452 * n_0  + -0.197200  * n_1  + 0.657232  * n_2  + 0.052956  * n_3  + -0.406795  * n_4  + -0.481384  * n_5  + 
                                 -0.264595  * n_6  + -0.222973  * n_7  +-0.354976  * n_8  +-0.377929  * n_9  + -0.310282  * n_10 + -0.229988  * n_11 + 
                                 -0.121623  * n_12 + -0.153214  * n_13 + -0.314893 * n_14 + -0.507960 * n_15 + -0.718880  * n_16 + -0.938835  * n_17 + 
                                 -1.385175  * n_18 + -0.560046 )
                                 
    n_25 = ActivationFunctionTanh(-0.446536 * n_0  + -0.212623  * n_1  + 0.660502  * n_2  + 0.051337  * n_3  + -0.363987  * n_4  + -0.398627  * n_5  + 
                                 -0.300080  * n_6  + -0.206941  * n_7  +-0.351769  * n_8  +-0.359350  * n_9  + -0.270055  * n_10 + -0.166549  * n_11 + 
                                 -0.026700  * n_12 + -0.030858  * n_13 + -0.217746 * n_14 + -0.442773 * n_15 + -0.689667  * n_16 + -0.947814  * n_17 + 
                                 -1.472945  * n_18 + -0.642802 ) 
 
    n_26 = ActivationFunctionTanh(0.162369  * n_0  + 0.080565   * n_1  +-0.925052  * n_2  + 0.407992  * n_3  + -0.042152  * n_4  + -0.044202  * n_5  + 
                                 -0.110007  * n_6  +-0.233211   * n_7  +-0.152412  * n_8  +-0.115330  * n_9  + -0.154931  * n_10 + -0.220581  * n_11 + 
                                 -0.333292  * n_12 + -0.559388  * n_13 + -0.494620 * n_14 + -0.389645 * n_15 + -0.257170  * n_16 + -0.106494  * n_17 + 
                                  0.224906  * n_18 + -0.543859  ) 
 
    _output := ActivationFunctionTanh(3.791166 * n_19  + 1.217929   * n_20  + -0.346824 * n_21  + 1.304904 * n_22  + 1.308826 * n_23  + 1.258987 * n_24  + 
                                      1.200855 * n_25  + -1.146649  * n_26  + -4.002537  )
                                      
 
// BTC 30 MINS 
 
 
fun_btc30()=>
    float _output = na 
    
    n_19 = ActivationFunctionTanh(-0.000023 * n_0  + -0.000607  * n_1  +  0.000241 * n_2  +  0.000345 * n_3  + -0.000419  * n_4  + -0.002526  * n_5  + 
                                 -0.000442  * n_6  + -0.000413  * n_7  + -0.000749 * n_8  + -0.001152 * n_9  + -0.001397  * n_10 + -0.001619  * n_11 + 
                                 -0.001930  * n_12 + -0.002685  * n_13 + -0.002812 * n_14 + -0.002931 * n_15 + -0.003046  * n_16 + -0.003158  * n_17 + 
                                 -0.003357  * n_18 + -0.450947 ) 
 
 
    n_20 = ActivationFunctionTanh(-0.000023 * n_0  + -0.000599  * n_1  + 0.000237  * n_2  +  0.000340 * n_3  + -0.000414  * n_4  + -0.002492  * n_5  + 
                                 -0.000437  * n_6  + -0.000408  * n_7  + -0.000739 * n_8  + -0.001137 * n_9  + -0.001379  * n_10 + -0.001597  * n_11 + 
                                 -0.001904  * n_12 + -0.002649  * n_13 + -0.002774 * n_14 + -0.002892 * n_15 + -0.003005  * n_16 + -0.003115  * n_17 + 
                                 -0.003312  * n_18 + -0.467159 ) 
 
 
    _output := ActivationFunctionTanh(0.097635  * n_19  + 0.096672  * n_20  + -0.103314 )  
 
 
// BTC 45 MINS 
 
fun_btc45()=>
    float _output = na 
    
    n_19 = ActivationFunctionTanh(0.456835  * n_0  + -2.030716  * n_1  + -0.798281 * n_2  + -3.530275 * n_3  + -1.188534  * n_4  + 1.279288   * n_5  + 
                                  1.336088  * n_6  + -0.464409  * n_7  + -0.263642 * n_8  +  0.027486 * n_9  +  0.254813  * n_10 +  0.462855  * n_11 + 
                                  0.753647  * n_12 +  0.911255  * n_13 +  0.516245 * n_14 +  0.005384 * n_15 + -0.577498  * n_16 + -1.201224  * n_17 + 
                                 -2.493732  * n_18 + -1.187097 ) 
 
 
    n_20 = ActivationFunctionTanh(0.345529  * n_0  + -1.999497  * n_1  + -0.782418 * n_2  + -2.315818 * n_3  + -0.431140  * n_4  +  1.196262  * n_5  + 
                                  0.918115  * n_6  + -0.657603  * n_7  + -0.386932 * n_8  + -0.051425 * n_9  +  0.173754  * n_10 +  0.383645  * n_11 + 
                                  0.669264  * n_12 +  0.800226  * n_13 +  0.405910 * n_14 + -0.106178 * n_15 + -0.692585  * n_16 +  -1.322158 * n_17 + 
                                 -2.632564  * n_18 + -0.832007  ) 
 
 
    _output := ActivationFunctionTanh(2.596823  * n_19  + 2.303467  * n_20  + -0.176739 )  
 
 
// BTC 1H 
 
fun_btc60()=>
    float _output = na 
    
    n_19 = ActivationFunctionTanh(0.000721  * n_0  + -0.000037  * n_1  +  0.000942 * n_2  +  0.001116 * n_3  +  0.001428  * n_4  + 0.000986   * n_5  + 
                                  0.000415  * n_6  +  0.000455  * n_7  +  0.000356 * n_8  +  0.000320 * n_9  +  0.000360  * n_10 +  0.000416  * n_11 + 
                                  0.000506  * n_12 +  0.000942  * n_13 +  0.001068 * n_14 +  0.001181 * n_15 +  0.001284  * n_16 +  0.001377  * n_17 + 
                                  0.001537  * n_18 + -0.449562 ) 
 
 
    n_20 = ActivationFunctionTanh(0.000712  * n_0  + -0.000037  * n_1  +  0.000929 * n_2  +  0.001101 * n_3  +  0.001409  * n_4  +  0.000973  * n_5  + 
                                  0.000410  * n_6  +  0.000449  * n_7  +  0.000351 * n_8  +  0.000316 * n_9  +  0.000355  * n_10 +  0.000411  * n_11 + 
                                  0.000499  * n_12 +  0.000930  * n_13 +  0.001053 * n_14 +  0.001165 * n_15 +  0.001266  * n_16 +  0.001358  * n_17 + 
                                  0.001516  * n_18 + -0.465792  ) 
 
 
    _output := ActivationFunctionTanh(-0.117262  * n_19  + -0.116105  * n_20  + -0.657030 )  
 
 
// BTC 2H 
 
fun_btc120()=>
    float _output = na 
    
    n_19 = ActivationFunctionTanh(0.000113  * n_0  +  0.000301  * n_1  + -0.000138 * n_2  + -0.000060 * n_3  + -0.000468  * n_4  + -0.001918  * n_5  + 
                                 -0.000607  * n_6  +  0.000071  * n_7  + -0.000122 * n_8  + -0.000414 * n_9  + -0.000571  * n_10 + -0.000722  * n_11 + 
                                 -0.000938  * n_12 + -0.001718  * n_13 + -0.001902 * n_14 + -0.002051 * n_15 + -0.002112  * n_16 + -0.002158  * n_17 + 
                                 -0.002224  * n_18 + -0.451214 ) 
 
 
    n_20 = ActivationFunctionTanh(0.000111  * n_0  +  0.000297  * n_1  + -0.000136 * n_2  + -0.000059 * n_3  + -0.000462  * n_4  + -0.001893  * n_5  + 
                                 -0.000599  * n_6  +  0.000070  * n_7  + -0.000120 * n_8  + -0.000408 * n_9  + -0.000564  * n_10 + -0.000712  * n_11 + 
                                 -0.000926  * n_12 + -0.001695  * n_13 + -0.001877 * n_14 + -0.002024 * n_15 + -0.002083  * n_16 + -0.002129  * n_17 + 
                                 -0.002194  * n_18 + -0.467423  ) 
 
 
    _output := ActivationFunctionTanh(0.089138  * n_19  + 0.088259  * n_20  + -0.125159 )  
 
 
// BTC 3H 
 
fun_btc180()=>
    float _output = na 
    
    n_19 = ActivationFunctionTanh(0.004831  * n_0  + -0.003359  * n_1  +  0.000649 * n_2  +  0.000370 * n_3  + -0.001701  * n_4  + -0.004579  * n_5  + 
                                 -0.001762  * n_6  +  0.001327  * n_7  + -0.000107 * n_8  + -0.001431 * n_9  + -0.002089  * n_10 + -0.002653  * n_11 + 
                                 -0.003390  * n_12 + -0.006023  * n_13 + -0.006537 * n_14 + -0.006888 * n_15 + -0.007180  * n_16 + -0.007425  * n_17 + 
                                 -0.007744  * n_18 + -0.450723 ) 
 
 
    n_20 = ActivationFunctionTanh(0.004766  * n_0  + -0.003314  * n_1  +  0.000639 * n_2  +  0.000365 * n_3  + -0.001679  * n_4  + -0.004518  * n_5  + 
                                 -0.001739  * n_6  +  0.001309  * n_7  + -0.000106 * n_8  + -0.001413 * n_9  + -0.002062  * n_10 + -0.002618  * n_11 + 
                                 -0.003345  * n_12 + -0.005943  * n_13 + -0.006449 * n_14 + -0.006796 * n_15 + -0.007085  * n_16 + -0.007325  * n_17 + 
                                 -0.007641  * n_18 + -0.466939 ) 
 
 
    _output := ActivationFunctionTanh(0.150474  * n_19  + 0.148997  * n_20  + 0.035489 )
 
 
// BTC 4H 
 
 
fun_btc240() => 
 
    float _output = na 
    
    n_19 = ActivationFunctionTanh(0.000298  * n_0  + -0.000209  * n_1  + -0.000044 * n_2  + -0.000178 * n_3  + -0.000555  * n_4  + -0.001287  * n_5  + 
                                 -0.000457  * n_6  + -0.000244  * n_7  + -0.000442 * n_8  + -0.000654 * n_9  + -0.000766  * n_10 + -0.000862  * n_11 + 
                                 -0.000983  * n_12 + -0.001239  * n_13 + -0.001244 * n_14 + -0.001216 * n_15 + -0.001169  * n_16 + -0.001127  * n_17 + 
                                 -0.001056  * n_18 + -0.386015 ) 
 
 
    n_20 = ActivationFunctionTanh(0.000346  * n_0  + -0.000242  * n_1  + -0.000050 * n_2  + -0.000206 * n_3  + -0.000643  * n_4  + -0.001492  * n_5  + 
                                 -0.000530  * n_6  + -0.000282  * n_7  + -0.000512 * n_8  + -0.000757 * n_9  +  -0.000887 * n_10 + -0.000999  * n_11 + 
                                 -0.001139  * n_12 + -0.001436  * n_13 + -0.001442 * n_14 + -0.001410 * n_15 + -0.001355  * n_16 + -0.001306  * n_17 + 
                                 -0.001225  * n_18 + -0.177099 ) 
 
 
    n_21 = ActivationFunctionTanh(0.000336  * n_0  + -0.000235 * n_1  + -0.000049 * n_2  + -0.000200  * n_3  + -0.000625 * n_4  + -0.001449  * n_5  + 
                                 -0.000515  * n_6  + -0.000274 * n_7  + -0.000498 * n_8  + -0.000736  * n_9  + -0.000862 * n_10 + -0.000971  * n_11 + 
                                 -0.001107  * n_12 + -0.001395 * n_13 + -0.001401 * n_14 + -0.001370  * n_15 + -0.001317 * n_16 + -0.001269  * n_17 + 
                                 -0.001190  * n_18 + -0.221836 ) 
 
    n_22 = ActivationFunctionTanh(0.000450 * n_0  + -0.000312  * n_1  + -0.000058 * n_2  + -0.000262 * n_3  + -0.000827  * n_4  + -0.001924  * n_5  + 
                                 -0.000680 * n_6  + -0.000360  * n_7  + -0.000657 * n_8  + -0.000974 * n_9  + -0.001142  * n_10 + -0.001287  * n_11 + 
                                 -0.001468 * n_12 + -0.001852  * n_13 + -0.001859 * n_14 + -0.001818 * n_15 + -0.001747  * n_16 + -0.001684  * n_17 + 
                                 -0.001579 * n_18 + 0.493827 ) 
 
    n_23 = ActivationFunctionTanh(0.000405  * n_0  + -0.000282  * n_1  + -0.000056 * n_2  + -0.000239 * n_3  + -0.000749  * n_4  + -0.001740   * n_5  + 
                                 -0.000616  * n_6  + -0.000328  * n_7  + -0.000596 * n_8  + -0.000882 * n_9  + -0.001034  * n_10 + -0.001165   * n_11 + 
                                 -0.001328  * n_12 + -0.001675  * n_13 + -0.001682 * n_14 + -0.001644 * n_15 + -0.001580  * n_16 + -0.001523   * n_17 + 
                                 -0.001428  * n_18 + 0.119740 )
                                 
    n_24 = ActivationFunctionTanh(0.000357  * n_0  + -0.000250  * n_1  + -0.000051 * n_2  + -0.000212 * n_3  + -0.000662  * n_4  + -0.001537  * n_5  + 
                                 -0.000545  * n_6  + -0.000291  * n_7  + -0.000528 * n_8  + -0.000780 * n_9  + -0.000914  * n_10 + -0.001030  * n_11 + 
                                 -0.001174  * n_12 + -0.001480  * n_13 + -0.001486 * n_14 + -0.001453 * n_15 + -0.001396  * n_16 + -0.001346  * n_17 + 
                                 -0.001262  * n_18 + -0.128058 ) 
 
    n_25 = ActivationFunctionTanh(0.000440  * n_0  + -0.000306  * n_1  + -0.000058 * n_2  + -0.000257 * n_3  + -0.000811  * n_4  + -0.001886  * n_5  + 
                                 -0.000667  * n_6  + -0.000354  * n_7  + -0.000645 * n_8  + -0.000956 * n_9  + -0.001120  * n_10 + -0.001262  * n_11 + 
                                 -0.001439  * n_12 + -0.001815  * n_13 + -0.001823 * n_14 + -0.001782 * n_15 + -0.001713  * n_16 + -0.001651  * n_17 + 
                                 -0.001548  * n_18 + 0.379354 ) 
 
    n_26 = ActivationFunctionTanh(0.000402  * n_0  + -0.000280  * n_1  + -0.000056 * n_2  + -0.000237 * n_3  + -0.000744  * n_4  + -0.001728  * n_5  + 
                                 -0.000612  * n_6  + -0.000326  * n_7  + -0.000592 * n_8  + -0.000877 * n_9  + -0.001027  * n_10 + -0.001157  * n_11 + 
                                 -0.001320  * n_12 + -0.001664  * n_13 + -0.001671 * n_14 + -0.001633 * n_15 + -0.001570  * n_16 + -0.001513  * n_17 + 
                                 -0.001419  * n_18 + 0.103566 ) 
 
    n_27 = ActivationFunctionTanh(0.000397  * n_0  + -0.000277  * n_1  + -0.000055 * n_2  + -0.000235 * n_3  + -0.000735  * n_4  + -0.001708  * n_5  + 
                                 -0.000605  * n_6  + -0.000322  * n_7  + -0.000585 * n_8  + -0.000866 * n_9  + -0.001015  * n_10 + -0.001143  * n_11 + 
                                 -0.001304  * n_12 + -0.001644  * n_13 + -0.001651 * n_14 + -0.001614 * n_15 + -0.001551  * n_16 + -0.001495  * n_17 + 
                                 -0.001402  * n_18 + 0.075917 ) 
 
    _output := ActivationFunctionTanh(0.065151 * n_19 + 0.073377 * n_20 + 0.071596 * n_21 + 0.099989 * n_22 + 0.085296 * n_23 + 0.075337 * n_24 + 
                                      0.095584 * n_25 + 0.084647 * n_26 + 0.083536 * n_27 + -0.267587)
 
 
// BTC 1D 
 
 
fun_btc1d() =>
 
    float _output = na 
    
    n_19 = ActivationFunctionTanh(-0.633481 * n_0  + -2.753370  * n_1  + -1.072644 * n_2  + -1.079077 * n_3  + -0.671968  * n_4  +  1.273822  * n_5  + 
                                 -1.417603  * n_6  + 1.920770   * n_7  + -0.750125 * n_8  + -0.996893 * n_9  + -0.344481  * n_10 + 0.446467   * n_11 + 
                                  1.471010  * n_12 + 0.867572   * n_13 + -0.032375 * n_14 + -0.592290 * n_15 + -0.681300  * n_16 + -0.265232  * n_17 + 
                                  1.979485  * n_18 + -1.345200) 
 
 
    n_20 = ActivationFunctionTanh(-0.251524 * n_0  + -0.264709  * n_1  + 3.330025  * n_2  + -1.758135 * n_3  + -1.373010  * n_4  + 1.024623   * n_5  + 
                                 -1.250970  * n_6  + 1.994500   * n_7  + -1.449193 * n_8  + -1.519239 * n_9  + -0.634501  * n_10 + 0.357019   * n_11 + 
                                  1.618683  * n_12 + 1.244217   * n_13 + 0.095207  * n_14 + -0.804969 * n_15 + -1.284815  * n_16 + -1.282321  * n_17 + 
                                  0.126797  * n_18 + -1.330270 ) 
 
 
    n_21 = ActivationFunctionTanh(-1.122826 * n_0  + -1.840816 * n_1  + -0.867246  * n_2  + -0.466440 * n_3  + -0.909494  * n_4  + 2.803960   * n_5  + 
                                 -0.404034  * n_6  + 3.146714  * n_7  + -0.734065  * n_8  + -1.349509 * n_9  + -0.647806  * n_10 + 0.225948   * n_11 + 
                                  1.342840  * n_12 + 0.374333  * n_13 + -0.685559  * n_14 + -1.339505 * n_15 + -1.443742  * n_16 + -0.964248  * n_17 + 
                                  1.614178  * n_18 + -1.065157 ) 
 
    n_22 = ActivationFunctionTanh(-1.614547* n_0  + -5.775336  * n_1  + 2.373008  * n_2  + 1.409746  * n_3  + 2.042374   * n_4  + -2.684138  * n_5  + 
                                 -3.278848 * n_6  + -4.058455  * n_7  + -3.065954 * n_8  + -1.084300 * n_9  + -0.373446  * n_10 +  0.033366  * n_11 + 
                                 0.274066  * n_12 + -1.467020  * n_13 + -2.112150 * n_14 + -2.522296 * n_15 + -2.657468  * n_16 + -2.519434  * n_17 + 
                                 -1.528425 * n_18 + 0.889220 ) 
 
    n_23 = ActivationFunctionTanh(-4.975500 * n_0  + -8.747454  * n_1  + 5.629647  * n_2  + -4.440584 * n_3  + -5.782330  * n_4  + 6.942848    * n_5  + 
                                  6.390540   * n_6  + 0.825718   * n_7  + 0.316324  * n_8  + -0.984473 * n_9  + -2.171598  * n_10 + -3.179572  * n_11 + 
                                 -4.102874   * n_12 + -1.132156  * n_13 + 0.333999  * n_14 + 1.388291  * n_15 + 1.964566   * n_16 + 2.076432   * n_17 + 
                                  1.104546   * n_18 + -3.212789 )
                                 
                                 
    n_24 = ActivationFunctionTanh(-6.984274 * n_0  + -0.314850  * n_1  + -10.744062* n_2  + 0.894127  * n_3  + 4.901208   * n_4  + 12.686739  * n_5  + 
                                 -1.080490  * n_6  + 2.438996   * n_7  + -3.434949 * n_8  + -3.154140 * n_9  + -1.260743  * n_10 + 0.773605   * n_11 + 
                                  3.179477  * n_12 + 4.365244   * n_13 + 3.115380  * n_14 + 1.991410  * n_15 + 1.100088   * n_16 + 0.474979   * n_17 + 
                                 -0.000249  * n_18 + -14.874917 ) 
                                 
 
    n_25 = ActivationFunctionTanh(-0.556166 * n_0  + -2.940919 * n_1  + -0.567908 * n_2  + -1.740896 * n_3  + -0.729119  * n_4  + -0.002763  * n_5  + 
                                 -2.089633  * n_6  +  0.156883 * n_7  + -1.439659 * n_8  + -1.052742 * n_9  + -0.257507  * n_10 + 0.607066   * n_11 + 
                                  1.710413  * n_12 + 1.624694  * n_13 + 0.828132  * n_14 + 0.301360  * n_15 + 0.173646   * n_16 + 0.483932   * n_17 + 
                                  2.346727  * n_18 + -1.441965 ) 
                                 
 
    n_26 = ActivationFunctionTanh(2.337116  * n_0  + -10.281617 * n_1  +  6.405422 * n_2  + 3.379239  * n_3  + -13.529903 * n_4  + -5.426502  * n_5  + 
                                  3.897074  * n_6  + -1.408937  * n_7  + 1.332063  * n_8  + 0.640766  * n_9  + -0.492073  * n_10 + -1.333120  * n_11 + 
                                 -2.021923  * n_12 + -3.785108  * n_13 + -4.272612 * n_14 + -4.483000 * n_15 + -4.343631  * n_16 + -3.853584  * n_17 + 
                                 -1.991719  * n_18 + 1.213537 ) 
 
    n_27 = ActivationFunctionTanh(3.475374  * n_0  + 1.138465   * n_1  + -0.511812 * n_2  + 3.546847  * n_3  + -7.835312  * n_4  + -2.012181  * n_5  + 
                                  4.277505  * n_6  + -0.820841  * n_7  + -5.434230 * n_8  + -5.021443 * n_9  + -3.856838  * n_10 + -2.747896  * n_11 + 
                                 -1.542846  * n_12 + -3.607826  * n_13 + -3.965775 * n_14 + -3.150198 * n_15 + -1.046815  * n_16 + 2.285882   * n_17 + 
                                  12.038928 * n_18 + 5.110039 ) 
 
    n_28 = ActivationFunctionTanh(0.119270  * n_0  + -7.072358  * n_1  + 2.153632  * n_2  + 1.003484  * n_3  + 3.255953   * n_4  + 1.094897   * n_5  + 
                                  4.873614  * n_6  + 0.544976   * n_7  + 1.331742  * n_8  + -1.306206 * n_9  + -2.919219  * n_10 + -4.517879  * n_11 + 
                                 -6.578425  * n_12 + -6.612962  * n_13 + -4.792399 * n_14 + -3.307242 * n_15 + -2.421065  * n_16 + -2.213441  * n_17 + 
                                 -3.688225  * n_18 + 1.535839  )
                                 
    n_29 = ActivationFunctionTanh(2.653389  * n_0  + -6.113949  * n_1  + 0.704048  * n_2  + -0.135280 * n_3  + -7.889001  * n_4  + 2.987226   * n_5  + 
                                  5.026648  * n_6  + 1.343060   * n_7  + -6.208260 * n_8  + -3.681602 * n_9  + -0.659369  * n_10 + 2.010165   * n_11 + 
                                  4.810512  * n_12 + 2.922294   * n_13 + 0.666526  * n_14 + -1.001707 * n_15 + -1.894088  * n_16 + -1.996187  * n_17 + 
                                 -0.136645  * n_18 + -2.300340  )
    
    _output := ActivationFunctionTanh(-1.548688 * n_19  + -2.072813  * n_20  + -2.113910  * n_21  + -5.412547 * n_22  + 4.062228 * n_23  + -8.646635 * n_24  + 
                                     -1.693534  * n_25  + -8.243129  * n_26  + -0.854547  * n_27  + 10.011633 * n_28  + -5.581477* n_29 + 0.411135 )  
 
 
// BTC 1W 
 
// BITCOIN 
 
fun_btc1w() => 
 
    float _output = na 
    
    n_19 = ActivationFunctionTanh(1.201680  * n_0  + 4.790233   * n_1  + -13.247836* n_2  + -3.518553 * n_3  + -6.729975  * n_4  + 17.274753  * n_5  + 
                                 -10.388693 * n_6  + -2.911250  * n_7  + -2.738169 * n_8  + -2.270430 * n_9  + -2.453312  * n_10 + -2.490656  * n_11 + 
                                 -2.170890  * n_12 + 1.189402   * n_13 + 1.890770  * n_14 + 2.383743  * n_15 +  2.695515  * n_16 + 2.803777   * n_17 + 
                                  2.651196  * n_18 + 4.104636 ) 
 
 
    n_20 = ActivationFunctionTanh(7.668744  * n_0  + -8.203325  * n_1  + -13.587246* n_2  + 3.468900  * n_3  + 3.433852   * n_4  + -11.015916 * n_5  + 
                                 -8.860698  * n_6  + -0.473582  * n_7  + 4.238994  * n_8  + 3.527646  * n_9  + 1.578865   * n_10 + -0.222423  * n_11 + 
                                 -2.035478  * n_12 + -0.383831  * n_13 + -0.099256 * n_14 + -0.341738 * n_15 + -0.984246  * n_16 + -2.363940  * n_17 + 
                                 -6.588227  * n_18 + 5.088957 ) 
 
 
    n_21 = ActivationFunctionTanh(-10.032236* n_0  + 4.815768  * n_1  + -2.417359  * n_2  + 2.446398  * n_3  + -3.901874  * n_4  + -3.210481  * n_5  + 
                                 3.557028   * n_6  + 7.880321  * n_7  + 5.681482   * n_8  + 0.897076  * n_9  + -1.029320  * n_10 + -1.864362  * n_11 + 
                                 -1.742023  * n_12 + 3.850158  * n_13 + 3.761906   * n_14 + 2.026571  * n_15 + -0.354672  * n_16 + -1.840503  * n_17 + 
                                 -2.922887  * n_18 + -4.577407 ) 
 
    n_22 = ActivationFunctionTanh(1.741262 * n_0  + 1.912236   * n_1  + 6.477892  * n_2  + -1.326788 * n_3  + 0.869487   * n_4  + 2.810600   * n_5  + 
                                 -6.166025 * n_6  + -8.550872  * n_7  + -0.580922 * n_8  + 1.616882  * n_9  + 0.687221   * n_10 + -0.584032  * n_11 + 
                                 -2.475119 * n_12 + -3.528662  * n_13 + -2.183762 * n_14 + -1.625953 * n_15 + -1.337159  * n_16 + 0.197613   * n_17 + 
                                 5.350869  * n_18 + -0.509766 ) 
 
    n_23 = ActivationFunctionTanh(-0.949103 * n_0  + -0.607215  * n_1  + -0.387264 * n_2  + 2.358837  * n_3  + -0.152102  * n_4  + -1.812956   * n_5  + 
                                 -2.974987  * n_6  + 1.322940   * n_7  + 1.334885  * n_8  + 0.267618  * n_9  + -0.300794  * n_10 + -0.705249   * n_11 + 
                                 -1.086082  * n_12 + -0.263323  * n_13 + 0.327146  * n_14 + 0.795826  * n_15 + 1.188228   * n_16 + 1.646276    * n_17 + 
                                 2.630985   * n_18 + -0.769845 )
                                 
                                 
    n_24 = ActivationFunctionTanh(-1.304055 * n_0  + -1.768287  * n_1  + -1.201598 * n_2  + -6.539091 * n_3  + -7.670284  * n_4  + 7.429614   * n_5  + 
                                 -3.488533  * n_6  + -9.388240  * n_7  + -3.937760 * n_8  + -0.677761 * n_9  + 0.372259   * n_10 + 1.053771   * n_11 + 
                                 1.770086   * n_12 + 4.428619   * n_13 + 5.409645  * n_14 + 6.441749  * n_15 + 7.462278   * n_16 + 8.390557   * n_17 + 
                                 9.990950   * n_18 + -8.729093 ) 
 
    n_25 = ActivationFunctionTanh(-3.753865 * n_0  + -10.000424 * n_1  + -7.531577 * n_2  + 1.962272  * n_3  + 3.222989   * n_4  + 8.067265   * n_5  + 
                                 -3.749201  * n_6  + -3.957342  * n_7  + -16.594564* n_8  + -12.142972* n_9  + -6.143112  * n_10 + -1.046300  * n_11 + 
                                  4.335467  * n_12 + 8.135875   * n_13 + 6.330516  * n_14 + 4.383505  * n_15 + 2.605501   * n_16 + 1.171710   * n_17 + 
                                 -0.634893  * n_18 + -2.024363 ) 
 
    n_26 = ActivationFunctionTanh(-3.613123 * n_0  + 6.850406   * n_1  + -5.668935 * n_2  + 6.155231  * n_3  + -1.127932  * n_4  + 0.011634   * n_5  + 
                                 -16.964766 * n_6  + -0.302819  * n_7  + -2.079260 * n_8  + -0.684992 * n_9  +  0.833319  * n_10 + 2.101285   * n_11 + 
                                  3.320521  * n_12 + 1.380460   * n_13 + -0.118373 * n_14 + -1.172973 * n_15 + -2.016801  * n_16 + -3.331162  * n_17 + 
                                 -6.696846  * n_18 + -1.426084 ) 
 
    n_27 = ActivationFunctionTanh(-6.301982 * n_0  + 1.008239   * n_1  + -0.596387  * n_2  + 1.300704  * n_3  + 1.353916   * n_4  + -4.990400  * n_5  + 
                                 -3.126689  * n_6  + -1.566456  * n_7  + -1.023235  * n_8  + -2.047515 * n_9  + -2.443359  * n_10 + -2.552728  * n_11 + 
                                 -2.367935  * n_12 + -0.615406  * n_13 + -0.390442  * n_14 + -0.328221 * n_15 + -0.363243  * n_16 + -0.430245  * n_17 + 
                                 -0.576579  * n_18 + 0.756044 ) 
                                 
                                 
    n_28 = ActivationFunctionTanh(-10.731304 * n_0  + 18.593990  * n_1  + -4.192338 * n_2  + -4.843999* n_3  + -3.704364  * n_4  + 19.068650  * n_5  + 
                                  11.714564  * n_6  + -15.959616 * n_7  + -5.964808 * n_8  + -0.531594* n_9  + 1.171733   * n_10 + 2.326418   * n_11 + 
                                  3.661263   * n_12 + 7.021172   * n_13 + 6.283531  * n_14 + 4.822940 * n_15 + 3.075006   * n_16 + 1.260840   * n_17 + 
                                 -2.360973   * n_18 + -2.463228 ) 
 
    _output := ActivationFunctionTanh(-21.620951 * n_19  + -5.099888  * n_20  + -8.320312 * n_21  + -6.986557 * n_22  + -1.548381 * n_23  + 8.281869 * n_24  + 
                                     8.902845    * n_25  + 10.057955  * n_26  + 4.794667  * n_27  + -3.723837 * n_28  + 5.820034  ) 
                                     
 
 
// 
 
res1 = input("1", type=input.resolution, title="1 min")
res2 = input("3", type=input.resolution, title="3 mins")
res3 = input("5", type=input.resolution, title="5 mins")
res4 = input("15", type=input.resolution, title="15 mins")
res5 = input("30", type=input.resolution, title="30 mins")
res6 = input("45", type=input.resolution, title="45 mins")
res7 = input("60", type=input.resolution, title="1H")
res8 = input("120", type=input.resolution, title="2H")
res9 = input("180", type=input.resolution, title="3H")
res10 = input("240", type=input.resolution, title="4H")
res11 = input("1D", type=input.resolution, title="1D")
res12 = input("1W", type=input.resolution, title="1W")
 
//
 
_output1  = fun_btc1()
_output3  = fun_btc3()
_output5  = fun_btc5()
_output15 = fun_btc15()
_output30 = fun_btc30()
_output45 = fun_btc45()
_output60 = fun_btc60()
_output120 = fun_btc120()
_output180 = fun_btc180()
_output240 = fun_btc240()
_output1d = fun_btc1d()
_output1w = fun_btc1w()
 
// 
 
float _output = na
 
if (timeframe.isminutes and timeframe.multiplier == 1)
 
    _output := _output1
 
if (timeframe.isminutes and timeframe.multiplier == 3)
 
    _output := _output3
 
if (timeframe.isminutes and timeframe.multiplier == 5)
 
    _output := _output5
 
if (timeframe.isminutes and timeframe.multiplier == 15)
 
    _output := _output15
 
if (timeframe.isminutes and timeframe.multiplier == 30)
 
    _output := _output30
 
if (timeframe.isminutes and timeframe.multiplier == 45)
 
    _output := _output45
 
if (timeframe.isminutes and timeframe.multiplier == 60)
 
    _output := _output60
 
if (timeframe.isminutes and timeframe.multiplier == 120)
 
    _output := _output120
    
if (timeframe.isminutes and timeframe.multiplier == 180)
 
    _output := _output180
 
if (timeframe.isminutes and timeframe.multiplier == 240)
 
    _output := _output240
 
if (timeframe.isdaily and timeframe.multiplier == 1)
 
    _output := _output1d
 
if (timeframe.isweekly and timeframe.multiplier == 1)
 
    _output := _output1w
 
 
// 
 
_chg_src = tangentdiff(src) * 100
 
_seed = (_output - _chg_src) 
 
 
// GOLDEN CROSS
 
// MACD : SEED 
 
 
fastLength   = 50
slowlength   = 200
signalLength = 25
 
 
macd   = ema(_seed, fastLength) - ema(_seed, slowlength)
signal = ema(macd, signalLength)
	   
 
hist = macd - signal
 
// Conditions : 
 
positive_condition = hist < 0 
negative_condition = hist > 0
 
neg_moment = crossover(macd,signal)
pos_moment = crossunder(macd,signal) 
 
col_bg = pos_moment ? color.teal : neg_moment ? color.maroon : na
bgcolor(col_bg , transp = 52 , title = "Background Color")
 
 
//Plot data
 
col_hist() => positive_condition ? color.new(#F5FFFA,0) : negative_condition ? color.new(#FF355E,0) : color.new(color.yellow,0)
col_histo = col_hist()
 
//Plot data
 
hline(0, color=#FFB300, linewidth = 1)
plot(hist, color=(positive_condition ? #00A86B : #D40000), style=plot.style_histogram,linewidth= 5 , title="Area", transp=30)
plot(hist, color=col_histo,style =plot.style_histogram, title="Forecast", linewidth=1)

← 返回列表