Şimdi başlat

Komut dosyalarını "binary" için ara

Trend Pulse Pro V2Trend Pulse Pro V2 (Non Repaint) TradingView Account Needed: Free You don't need to be an expert to use Trend Pulse Pro. Just follow the signals and that's all and use simple Fibonacci levels to find stop loss and take profit! You can increase the win rate even more by following some simple technical analysis, for example, when trend breaks (price break signal level) you can use that as support become resistance level (sell) or resistance becomes support (buy): No complex things. No waste of time. And although you won't win 100% of the trades (no signals can guarantee that), your trading will surely improve a lot! Even someone with almost no trading experience can read the simple trading rules given in the included user guide, watch the how-to videos and follow Trend Pulse Pro’s signals to consistently make smarter trades. With Trend Pulse Pro you will get accurate buy and sell signals every time there is a new trading opportunity so that you never miss any big price movements and makes your trading both easier and more profitable. How to use the signals and alerts: Trend Pulse Pro automatically analyze trend and price action to give you a signal when there's a good trade. These trend signals and alerts are derived from live data but the stability of our code allows it to not repaint. Trend Pulse Pro allow you to easily determine the trend and will give you buy and sell entry levels. Works on all markets on all time frames so it's suitable for scalpers, day and swing traders. If you want more details, the link is in the signature. Disclaimer: Past performance is not indicative of future performance. No representation is being made that any results discussed within the service and its related media content will be achieved. All opinions, news, research, analyses, prices or other information is provided as general market commentary and not as investment advice. TradingWalk, their members, shareholders, employees, agents, representatives and resellers do not warrant the completeness, accuracy or timeliness of the information supplied, and they shall not be liable for any loss or damages, consequential or otherwise, which may arise from the use or reliance of the TradingWalk service and its content. © 2019 TradingWalk. TradingWalk indicators are built for TradingView. TradingWalk is on no way a part of TradingView.
Pine Script® göstergesi
tradingwalk tarafından
189
MM-Microtrend-Reversal-IndicatorThis indicator detects microtrend reversals based on crossing of the DMI+ and DMI- + signals It indicates the trigger event on the chart as well as the reversal candle In addition to that it shows a countdown above the bars This is helping when multiple reversals occur Important: when the Bollinger Bands are crossed in the previous bars it's possible that the prognosted reversal will NOT show up Recommended timeframes are M1 and M2 Avoid trading sideway trends, the reverals are low and reversal triggers and assumed reversal candles could get chaotic
Pine Script® göstergesi
Meunier tarafından
28
MM-Microtrend-Reversal-IndicatorThis indicator detects microtrend reversals based on crossings of the DMI+ and DMI- signals It indicates the trigger event on the chart as well as the reversal candle In addition to that it shows a countdown above the bars This is helping when multiple reversals occur. Important: when the Bollinger Bands are crossed in the previous bars it's possible that the prognosted reversal will NOT show up Recommended timeframes are M1 and M2 Avoid trading sideway trends, the reversals are low and reversal triggers and assumed reversal candles could get chaotic sometimes
Pine Script® göstergesi
Meunier tarafından
2
Chatterjee CorrelationThis is my first attempt on implementing a statistical method. This problem was given to me by @lejmer (who also helped me later on building more efficient code to achieve this) when we were debating on the need for higher resource allocation to run scripts so it can run longer and faster. The major problem faced by those who want to implement statistics based methods is that they run out of processing time or need to limit the data samples. My point was that such things need be implemented with an algorithm which suits pine instead of trying to port a python code directly. And yes, I am able to demonstrate that by using this implementation of Chatterjee Correlation. 🎲 What is Chatterjee Correlation? The Chatterjee rank Correlation Coefficient (CCC) is a method developed by Sourav Chatterjee which can be used to study non linear correlation between two series. Full documentation on the method can be found here: arxiv.org In short, the formula which we are implementing here is: Algorithm can be simplified as follows: 1. Get the ranks of X 2. Get the ranks of Y 3. Sort ranks of Y in the order of X (Lets call this SortedYIndices) 4. Calculate the sum of adjacent Y ranks in SortedYIndices (Lets call it as SumOfAdjacentSortedIndices) 5. And finally the correlation coefficient can be calculated by using simple formula CCC = 1 - (3*SumOfAdjacentSortedIndices)/(n^2 - 1) 🎲 Looks simple? What is the catch? Mistake many people do here is that they think in Python/Java/C etc while coding in Pine. This makes code less efficient if it involves arrays and loops. And the simple code may look something like this. var xArray = array.new() var yArray = array.new() array.push(xArray, x) array.push(yArray, y) sortX = array.sort_indices(xArray) sortY = array.sort_indices(yArray) SumOfAdjacentSortedIndices = 0.0 index = array.get(xSortIndices, 0) for i=1 to n > 1? n -1 : na indexNext = array.get(sortX, i) SumOfAdjacentSortedIndices += math.abs(array.get(sortY, indexNext)-array.get(sortY, index)) index := indexNext correlation := 1 - 3*SumOfAdjacentSortedIndices/(math.pow(n,2)-1) But, problem here is the number of loops run. Remember pine executes the code on every bar. There are loops run in array.sort_indices and another loop we are running to calculate SumOfAdjacentSortedIndices. Due to this, chances of program throwing runtime errors due to script running for too long are pretty high. This limits greatly the number of samples against which we can run the study. The options to overcome are Limit the sample size and calculate only between certain bars - this is not ideal as smaller sets are more likely to yield false or inconsistent results. Start thinking in pine instead of python and code in such a way that it is optimised for pine. - This is exactly what we have done in the published code. 🎲 How to think in Pine? In order to think in pine, you should try to eliminate the loops as much as possible. Specially on the data which is continuously growing. My first thought was that sorting takes lots of time and need to find a better way to sort series - specially when it is a growing data set. Hence, I came up with this library which implements Binary Insertion Sort. Replacing array.sort_indices with binary insertion sort will greatly reduce the number of loops run on each bar. In binary insertion sort, the array will remain sorted and any item we add, it will keep adding it in the existing sort order so that there is no need to run separate sort. This allows us to work with bigger data sets and can utilise full 20,000 bars for calculation instead of few 100s. However, last loop where we calculate SumOfAdjacentSortedIndices is not replaceable easily. Hence, we only limit these iterations to certain bars (Even though we use complete sample size). Plots are made for only those bars where the results need to be printed. 🎲 Implementation Current implementation is limited to few combinations of x and fixed y. But, will be converting this into library soon - which means, programmers can plug any x and y and get the correlation. Our X here can be Average volume ATR And our Y is distance of price from moving average - which identifies trend. Thus, the indicator here helps to understand the correlation coefficient between volume and trend OR volatility and trend for given ticker and timeframe. Value closer to 1 means highly correlated and value closer to 0 means least correlated. Please note that this method will not tell how these values are correlated. That is, we will not be able to know if higher volume leads to higher trend or lower trend. But, we can say whether volume impacts trend or not. Please note that values can differ by great extent for different timeframes. For example, if you look at 1D timeframe, you may get higher value of correlation coefficient whereas lower value for 1m timeframe. This means, volume to trend correlation is higher in 1D timeframe and lower in lower timeframes.
Pine Script® göstergesi
Trendoscope tarafından
10
InsertionSortLibrary "InsertionSort" Library of sorting algorithm for binary insertion sort and related methods method binary_insertion_sort(sortedArray, item, order)   binary insertion sort - inserts item into sorted array while maintaining sort order   Namespace types: array   Parameters:      sortedArray (array) : array which is assumed to be sorted in the requested order      item (float) : float|int item which needs to be inserted into sorted array      order (series ORDER) : Sort order - positive number means ascending order whereas negative number represents descending order   Returns: int index at which the item is inserted into sorted array method binary_insertion_sort(sortedArray, item, order)   Namespace types: array   Parameters:      sortedArray (array)      item (int)      order (series ORDER)
Pine Script® kütüphanesi
Trendoscope tarafından
MM-Burj Khalifa IndicatorThis indicator uses several signals to visualize a "perfect candle" to enter a trade. It colors the background to identify the zones of interest (multiple configurable high or low RSI zones). Underlying is a trendbar with the current MACD direction. The indicator is using signals of: --MACD --RSI --PVT --ATR --AD and DMI+/DMI- When all 7 criterias are met it highlights the candle. It also creates different colums with different height and width, so that you can see which signal is OK and which is maybe missing. When all signals are on GO you'll see a Burj-Khalifa-like figure. If not all signals are on GO you'see crippled versions. To be clear: it's not intended to detect trends or supertrends or reversals. It's purpose it's just to decide if this current candle is really going in the right direction. The Burj-Khalifa indicator could help to confirm the entry point of an trade which was already planned.
Pine Script® göstergesi
Meunier tarafından
31
Trading IQ - ICT LibraryLibrary "ICTlibrary" Used to calculate various ICT related price levels and strategies. An ongoing project. Hello Coders! This library is meant for sourcing ICT related concepts. While some functions might generate more output than you require, you can specify "Lite Mode" as "true" in applicable functions to slim down necessary inputs. isLastBar(userTF)   Identifies the last bar on the chart before a timeframe change   Parameters:      userTF (simple int) : the timeframe you wish to calculate the last bar for, must be converted to integer using 'timeframe.in_seconds()'   Returns: bool true if bar on chart is last bar of higher TF, dalse if bar on chart is not last bar of higher TF necessaryData(atrTF)   returns necessaryData UDT for historical data access   Parameters:      atrTF (float) : user-selected timeframe ATR value.   Returns: logZ. log return Z score, used for calculating order blocks. method gradBoxes(gradientBoxes, idColor, timeStart, bottom, top, rightCoordinate)   creates neon like effect for box drawings   Namespace types: array   Parameters:      gradientBoxes (array) : an array.new() to store the gradient boxes      idColor (color)      timeStart (int) : left point of box      bottom (float) : bottom of box price point      top (float) : top of box price point      rightCoordinate (int) : right point of box   Returns: void checkIfTraded(tradeName)   checks if recent trade is of specific name   Parameters:      tradeName (string)   Returns: bool true if recent trade id matches target name, false otherwise checkIfClosed(tradeName)   checks if recent closed trade is of specific name   Parameters:      tradeName (string)   Returns: bool true if recent closed trade id matches target name, false otherwise IQZZ(atrMult, finalTF)   custom ZZ to quickly determine market direction.   Parameters:      atrMult (float) : an atr multiplier used to determine the required price move for a ZZ direction change      finalTF (string) : the timeframe used for the atr calcuation   Returns: dir market direction. Up => 1, down => -1 method drawBos(id, startPoint, getKeyPointTime, getKeyPointPrice, col, showBOS, isUp)   calculates and draws Break Of Structure   Namespace types: array   Parameters:      id (array)      startPoint (chart.point)      getKeyPointTime (int) : the actual time of startPoint, simplystartPoint.time      getKeyPointPrice (float) : the actual time of startPoint, simplystartPoint.price      col (color) : color of the BoS line / label      showBOS (bool) : whether to show label/line. This function still calculates internally for other ICT related concepts even if not drawn.      isUp (bool) : whether BoS happened during price increase or price decrease.   Returns: void method drawMSS(id, startPoint, getKeyPointTime, getKeyPointPrice, col, showMSS, isUp, upRejections, dnRejections, highArr, lowArr, timeArr, closeArr, openArr, atrTFarr, upRejectionsPrices, dnRejectionsPrices)   calculates and draws Market Structure Shift. This data is also used to calculate Rejection Blocks.   Namespace types: array   Parameters:      id (array)      startPoint (chart.point)      getKeyPointTime (int) : the actual time of startPoint, simplystartPoint.time      getKeyPointPrice (float) : the actual time of startPoint, simplystartPoint.price      col (color) : color of the MSS line / label      showMSS (bool) : whether to show label/line. This function still calculates internally for other ICT related concepts even if not drawn.      isUp (bool) : whether MSS happened during price increase or price decrease.      upRejections (array)      dnRejections (array)      highArr (array) : array containing historical highs, should be taken from the UDT "necessaryData" defined above      lowArr (array) : array containing historical lows, should be taken from the UDT "necessaryData" defined above      timeArr (array) : array containing historical times, should be taken from the UDT "necessaryData" defined above      closeArr (array) : array containing historical closes, should be taken from the UDT "necessaryData" defined above      openArr (array) : array containing historical opens, should be taken from the UDT "necessaryData" defined above      atrTFarr (array) : array containing historical atr values (of user-selected TF), should be taken from the UDT "necessaryData" defined above      upRejectionsPrices (array) : array containing up rejections prices. Is sorted and used to determine selective looping for invalidations.      dnRejectionsPrices (array) : array containing down rejections prices. Is sorted and used to determine selective looping for invalidations.   Returns: void method getTime(id, compare, timeArr)   gets time of inputted price (compare) in an array of data this is useful when the user-selected timeframe for ICT concepts is greater than the chart's timeframe   Namespace types: array   Parameters:      id (array) : the array of data to search through, to find which index has the same value as "compare"      compare (float) : the target data point to find in the array      timeArr (array) : array of historical times   Returns: the time that the data point in the array was recorded method OB(id, highArr, signArr, lowArr, timeArr, sign)   store bullish orderblock data   Namespace types: array   Parameters:      id (array)      highArr (array) : array of historical highs      signArr (array) : array of historical price direction "math.sign(close - open)"      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      sign (int) : orderblock direction, -1 => bullish, 1 => bearish   Returns: void OTEstrat(OTEstart, future, closeArr, highArr, lowArr, timeArr, longOTEPT, longOTESL, longOTElevel, shortOTEPT, shortOTESL, shortOTElevel, structureDirection, oteLongs, atrTF, oteShorts)   executes the OTE strategy   Parameters:      OTEstart (chart.point)      future (int) : future time point for drawings      closeArr (array) : array of historical closes      highArr (array) : array of historical highs      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      longOTEPT (string) : user-selected long OTE profit target, please create an input.string() for this using the example below      longOTESL (int) : user-selected long OTE stop loss, please create an input.string() for this using the example below      longOTElevel (float) : long entry price of selected retracement ratio for OTE      shortOTEPT (string) : user-selected short OTE profit target, please create an input.string() for this using the example below      shortOTESL (int) : user-selected short OTE stop loss, please create an input.string() for this using the example below      shortOTElevel (float) : short entry price of selected retracement ratio for OTE      structureDirection (string) : current market structure direction, this should be "Up" or "Down". This is used to cancel pending orders if market structure changes      oteLongs (bool) : input.bool() for whether OTE longs can be executed      atrTF (float) : atr of the user-seleceted TF      oteShorts (bool) : input.bool() for whether OTE shorts can be executed @exampleInputs oteLongs = input.bool(defval = false, title = "OTE Longs", group = "Optimal Trade Entry") longOTElevel = input.float(defval = 0.79, title = "Long Entry Retracement Level", options = , group = "Optimal Trade Entry") longOTEPT = input.string(defval = "-0.5", title = "Long TP", options = , group = "Optimal Trade Entry") longOTESL = input.int(defval = 0, title = "How Many Ticks Below Swing Low For Stop Loss", group = "Optimal Trade Entry") oteShorts = input.bool(defval = false, title = "OTE Shorts", group = "Optimal Trade Entry") shortOTElevel = input.float(defval = 0.79, title = "Short Entry Retracement Level", options = , group = "Optimal Trade Entry") shortOTEPT = input.string(defval = "-0.5", title = "Short TP", options = , group = "Optimal Trade Entry") shortOTESL = input.int(defval = 0, title = "How Many Ticks Above Swing Low For Stop Loss", group = "Optimal Trade Entry")   Returns: void (0) displacement(logZ, atrTFreg, highArr, timeArr, lowArr, upDispShow, dnDispShow, masterCoords, labelLevels, dispUpcol, rightCoordinate, dispDncol, noBorders)   calculates and draws dispacements   Parameters:      logZ (float) : log return of current price, used to determine a "significant price move" for a displacement      atrTFreg (float) : atr of user-seleceted timeframe      highArr (array) : array of historical highs      timeArr (array) : array of historical times      lowArr (array) : array of historical lows      upDispShow (int) : amount of historical upside displacements to show      dnDispShow (int) : amount of historical downside displacements to show      masterCoords (map) : a map to push the most recent displacement prices into, useful for having key levels in one data structure      labelLevels (string) : used to determine label placement for the displacement, can be inside box, outside box, or none, example below      dispUpcol (color) : upside displacement color      rightCoordinate (int) : future time for displacement drawing, best is "last_bar_time"      dispDncol (color) : downside displacement color      noBorders (bool) : input.bool() to remove box borders, example below @exampleInputs labelLevels = input.string(defval = "Inside" , title = "Box Label Placement", options = ) noBorders = input.bool(defval = false, title = "No Borders On Levels")   Returns: void method getStrongLow(id, startIndex, timeArr, lowArr, strongLowPoints)   unshift strong low data to array id   Namespace types: array   Parameters:      id (array)      startIndex (int) : the starting index for the timeArr array of the UDT "necessaryData". this point should start from at least 1 pivot prior to find the low before an upside BoS      timeArr (array) : array of historical times      lowArr (array) : array of historical lows      strongLowPoints (array) : array of strong low prices. Used to retrieve highest strong low price and see if need for removal of invalidated strong lows   Returns: void method getStrongHigh(id, startIndex, timeArr, highArr, strongHighPoints)   unshift strong high data to array id   Namespace types: array   Parameters:      id (array)      startIndex (int) : the starting index for the timeArr array of the UDT "necessaryData". this point should start from at least 1 pivot prior to find the high before a downside BoS      timeArr (array) : array of historical times      highArr (array) : array of historical highs      strongHighPoints (array)   Returns: void equalLevels(highArr, lowArr, timeArr, rightCoordinate, equalHighsCol, equalLowsCol, liteMode)   used to calculate recent equal highs or equal lows   Parameters:      highArr (array) : array of historical highs      lowArr (array) : array of historical lows      timeArr (array) : array of historical times      rightCoordinate (int) : a future time (right for boxes, x2 for lines)      equalHighsCol (color) : user-selected color for equal highs drawings      equalLowsCol (color) : user-selected color for equal lows drawings      liteMode (bool) : optional for a lite mode version of an ICT strategy. For more control over drawings leave as "True", "False" will apply neon effects   Returns: void quickTime(timeString)   used to quickly determine if a user-inputted time range is currently active in NYT time   Parameters:      timeString (string) : a time range   Returns: true if session is active, false if session is inactive macros(showMacros, noBorders)   used to calculate and draw session macros   Parameters:      showMacros (bool) : an input.bool() or simple bool to determine whether to activate the function      noBorders (bool) : an input.bool() to determine whether the box anchored to the session should have borders   Returns: void po3(tf, left, right, show)   use to calculate HTF po3 candle @tip only call this function on "barstate.islast"   Parameters:      tf (simple string)      left (int) : the left point of the candle, calculated as bar_index + left,      right (int) : :the right point of the candle, calculated as bar_index + right,      show (bool) : input.bool() whether to show the po3 candle or not   Returns: void silverBullet(silverBulletStratLong, silverBulletStratShort, future, userTF, H, L, H2, L2, noBorders, silverBulletLongTP, historicalPoints, historicalData, silverBulletLongSL, silverBulletShortTP, silverBulletShortSL)   used to execute the Silver Bullet Strategy   Parameters:      silverBulletStratLong (simple bool)      silverBulletStratShort (simple bool)      future (int) : a future time, used for drawings, example "last_bar_time"      userTF (simple int)      H (float) : the high price of the user-selected TF      L (float) : the low price of the user-selected TF      H2 (float) : the high price of the user-selected TF      L2 (float) : the low price of the user-selected TF      noBorders (bool) : an input.bool() used to remove the borders from box drawings      silverBulletLongTP (series silverBulletLevels)      historicalPoints (array)      historicalData (necessaryData)      silverBulletLongSL (series silverBulletLevels)      silverBulletShortTP (series silverBulletLevels)      silverBulletShortSL (series silverBulletLevels)   Returns: void method invalidFVGcheck(FVGarr, upFVGpricesSorted, dnFVGpricesSorted)   check if existing FVGs are still valid   Namespace types: array   Parameters:      FVGarr (array)      upFVGpricesSorted (array) : an array of bullish FVG prices, used to selective search through FVG array to remove invalidated levels      dnFVGpricesSorted (array) : an array of bearish FVG prices, used to selective search through FVG array to remove invalidated levels   Returns: void (0) method drawFVG(counter, FVGshow, FVGname, FVGcol, data, masterCoords, labelLevels, borderTransp, liteMode, rightCoordinate)   draws FVGs on last bar   Namespace types: map   Parameters:      counter (map) : a counter, as map, keeping count of the number of FVGs drawn, makes sure that there aren't more FVGs drawn than int FVGshow      FVGshow (int) : the number of FVGs to show. There should be a bullish FVG show and bearish FVG show. This function "drawFVG" is used separately for bearish FVG and bullish FVG.      FVGname (string) : the name of the FVG, "FVG Up" or "FVG Down"      FVGcol (color) : desired FVG color      data (FVG)      masterCoords (map) : a map containing the names and price points of key levels. Used to define price ranges.      labelLevels (string) : an input.string with options "Inside", "Outside", "Remove". Determines whether FVG labels should be inside box, outside, or na.      borderTransp (int)      liteMode (bool)      rightCoordinate (int) : the right coordinate of any drawings. Must be a time point.   Returns: void invalidBlockCheck(bullishOBbox, bearishOBbox, userTF)   check if existing order blocks are still valid   Parameters:      bullishOBbox (array) : an array declared using the UDT orderBlock that contains bullish order block related data      bearishOBbox (array) : an array declared using the UDT orderBlock that contains bearish order block related data      userTF (simple int)   Returns: void (0) method lastBarRejections(id, rejectionColor, idShow, rejectionString, labelLevels, borderTransp, liteMode, rightCoordinate, masterCoords)   draws rejectionBlocks on last bar   Namespace types: array   Parameters:      id (array) : the array, an array of rejection block data declared using the UDT rejection block      rejectionColor (color) : the desired color of the rejection box      idShow (int)      rejectionString (string) : the desired name of the rejection blocks      labelLevels (string) : an input.string() to determine if labels for the block should be inside the box, outside, or none.      borderTransp (int)      liteMode (bool) : an input.bool(). True = neon effect, false = no neon.      rightCoordinate (int) : atime for the right coordinate of the box      masterCoords (map) : a map that stores the price of key levels and assigns them a name, used to determine price ranges   Returns: void method OBdraw(id, OBshow, BBshow, OBcol, BBcol, bullishString, bearishString, isBullish, labelLevels, borderTransp, liteMode, rightCoordinate, masterCoords)   draws orderblocks and breaker blocks for data stored in UDT array()   Namespace types: array   Parameters:      id (array) : the array, an array of order block data declared using the UDT orderblock      OBshow (int) : the number of order blocks to show      BBshow (int) : the number of breaker blocks to show      OBcol (color) : color of order blocks      BBcol (color) : color of breaker blocks      bullishString (string) : the title of bullish blocks, which is a regular bullish orderblock or a bearish orderblock that's converted to breakerblock      bearishString (string) : the title of bearish blocks, which is a regular bearish orderblock or a bullish orderblock that's converted to breakerblock      isBullish (bool) : whether the array contains bullish orderblocks or bearish orderblocks. If bullish orderblocks, the array will naturally contain bearish BB, and if bearish OB, the array will naturally contain bullish BB      labelLevels (string) : an input.string() to determine if labels for the block should be inside the box, outside, or none.      borderTransp (int)      liteMode (bool) : an input.bool(). True = neon effect, false = no neon.      rightCoordinate (int) : atime for the right coordinate of the box      masterCoords (map) : a map that stores the price of key levels and assigns them a name, used to determine price ranges   Returns: void FVG   UDT for FVG calcualtions   Fields:      H (series float) : high price of user-selected timeframe      L (series float) : low price of user-selected timeframe      direction (series string) : FVG direction => "Up" or "Down"      T (series int) : => time of bar on user-selected timeframe where FVG was created      fvgLabel (series label) : optional label for FVG      fvgLineTop (series line) : optional line for top of FVG      fvgLineBot (series line) : optional line for bottom of FVG      fvgBox (series box) : optional box for FVG labelLine   quickly pair a line and label together as UDT   Fields:      lin (series line) : Line you wish to pair with label      lab (series label) : Label you wish to pair with line orderBlock   UDT for order block calculations   Fields:      orderBlockData (array) : array containing order block x and y points      orderBlockBox (series box) : optional order block box      vioCount (series int) : = 0 violation count of the order block. 0 = Order Block, 1 = Breaker Block      traded (series bool)      status (series string) : = "OB" status == "OB" => Level is order block. status == "BB" => Level is breaker block.      orderBlockLab (series label) : options label for the order block / breaker block. strongPoints   UDT for strong highs and strong lows   Fields:      price (series float) : price of the strong high or strong low      timeAtprice (series int) : time of the strong high or strong low      strongPointLabel (series label) : optional label for strong point      strongPointLine (series line) : optional line for strong point      overlayLine (series line) : optional lines for strong point to enhance visibility      overlayLine2 (series line) : optional lines for strong point to enhance visibility displacement   UDT for dispacements   Fields:      highPrice (series float) : high price of displacement      lowPrice (series float) : low price of displacement      timeAtPrice (series int) : time of bar where displacement occurred      displacementBox (series box) : optional box to draw displacement      displacementLab (series label) : optional label for displacement po3data   UDT for po3 calculations   Fields:      dHigh (series float) : higher timeframe high price      dLow (series float) : higher timeframe low price      dOpen (series float) : higher timeframe open price      dClose (series float) : higher timeframe close price      po3box (series box) : box to draw po3 candle body      po3line (array) : line array to draw po3 wicks      po3Labels (array) : label array to label price points of po3 candle macros   UDT for session macros   Fields:      sessions (array) : Array of sessions, you can populate this array using the "quickTime" function located above "export macros".      prices (matrix) : Matrix of session data -> open, high, low, close, time      sessionTimes (array) : Array of session names. Pairs with array sessions.      sessionLines (matrix) : Optional array for sesion drawings. OTEtimes   UDT for data storage and drawings associated with OTE strategy   Fields:      upTimes (array) : time of highest point before trade is taken      dnTimes (array) : time of lowest point before trade is taken      tpLineLong (series line) : line to mark tp level long      tpLabelLong (series label) : label to mark tp level long      slLineLong (series line) : line to mark sl level long      slLabelLong (series label) : label to mark sl level long      tpLineShort (series line) : line to mark tp level short      tpLabelShort (series label) : label to mark tp level short      slLineShort (series line) : line to mark sl level short      slLabelShort (series label) : label to mark sl level short sweeps   UDT for data storage and drawings associated with liquidity sweeps   Fields:      upSweeps (matrix) : matrix containing liquidity sweep price points and time points for up sweeps      dnSweeps (matrix) : matrix containing liquidity sweep price points and time points for down sweeps      upSweepDrawings (array) : optional up sweep box array. Pair the size of this array with the rows or columns,      dnSweepDrawings (array) : optional up sweep box array. Pair the size of this array with the rows or columns, raidExitDrawings   UDT for drawings associated with the Liquidity Raid Strategy   Fields:      tpLine (series line) : tp line for the liquidity raid entry      tpLabel (series label) : tp label for the liquidity raid entry      slLine (series line) : sl line for the liquidity raid entry      slLabel (series label) : sl label for the liquidity raid entry m2022   UDT for data storage and drawings associated with the Model 2022 Strategy   Fields:      mTime (series int) : time of the FVG where entry limit order is placed      mIndex (series int) : array index of FVG where entry limit order is placed. This requires an array of FVG data, which is defined above.      mEntryDistance (series float) : the distance of the FVG to the 50% range. M2022 looks for the fvg closest to 50% mark of range.      mEntry (series float) : the entry price for the most eligible fvg      fvgHigh (series float) : the high point of the eligible fvg      fvgLow (series float) : the low point of the eligible fvg      longFVGentryBox (series box) : long FVG box, used to draw the eligible FVG      shortFVGentryBox (series box) : short FVG box, used to draw the eligible FVG      line50P (series line) : line used to mark 50% of the range      line100P (series line) : line used to mark 100% (top) of the range      line0P (series line) : line used to mark 0% (bottom) of the range      label50P (series label) : label used to mark 50% of the range      label100P (series label) : label used to mark 100% (top) of the range      label0P (series label) : label used to mark 0% (bottom) of the range      sweepData (array) silverBullet   UDT for data storage and drawings associated with the Silver Bullet Strategy   Fields:      session (series bool)      sessionStr (series string) : name of the session for silver bullet      sessionBias (series string)      sessionHigh (series float) : = high high of session // use math.max(silverBullet.sessionHigh, high)      sessionLow (series float) : = low low of session // use math.min(silverBullet.sessionLow, low)      sessionFVG (series float) : if applicable, the FVG created during the session      sessionFVGdraw (series box) : if applicable, draw the FVG created during the session      traded (series bool)      tp (series float) : tp of trade entered at the session FVG      sl (series float) : sl of trade entered at the session FVG      sessionDraw (series box) : optional draw session with box      sessionDrawLabel (series label) : optional label session with label silverBulletDrawings   UDT for trade exit drawings associated with the Silver Bullet Strategy   Fields:      tpLine (series line) : tp line drawing for strategy      tpLabel (series label) : tp label drawing for strategy      slLine (series line) : sl line drawing for strategy      slLabel (series label) : sl label drawing for strategy unicornModel   UDT for data storage and drawings associated with the Unicorn Model Strategy   Fields:      hPoint (chart.point)      hPoint2 (chart.point)      hPoint3 (chart.point)      breakerBlock (series box) : used to draw the breaker block required for the Unicorn Model      FVG (series box) : used to draw the FVG required for the Unicorn model      topBlock (series float) : price of top of breaker block, can be used to detail trade entry      botBlock (series float) : price of bottom of breaker block, can be used to detail trade entry      startBlock (series int) : start time of the breaker block, used to set the "left = " param for the box      includes (array) : used to store the time of the breaker block, or FVG, or the chart point sequence that setup the Unicorn Model.      entry (series float) : // eligible entry price, for longs"math.max(topBlock, FVG.get_top())",      tpLine (series line) : optional line to mark PT      tpLabel (series label) : optional label to mark PT      slLine (series line) : optional line to mark SL      slLabel (series label) : optional label to mark SL rejectionBlocks   UDT for data storage and drawings associated with rejection blocks   Fields:      rejectionPoint (chart.point)      bodyPrice (series float) : candle body price closest to the rejection point, for "Up" rejections => math.max(open, close),      rejectionBox (series box) : optional box drawing of the rejection block      rejectionLabel (series label) : optional label for the rejection block equalLevelsDraw   UDT for data storage and drawings associated with equal highs / equal lows   Fields:      connector (series line) : single line placed at the first high or low, y = avgerage of distinguished equal highs/lows      connectorLab (series label) : optional label to be placed at the highs or lows      levels (array) : array containing the equal highs or lows prices      times (array) : array containing the equal highs or lows individual times      startTime (series int) : the time of the first high or low that forms a sequence of equal highs or lows      radiate (array) : options label to "radiate" the label in connector lab. Can be used for anything necessaryData   UDT for data storage of historical price points.   Fields:      highArr (array) : array containing historical high points      lowArr (array) : array containing historical low points      timeArr (array) : array containing historical time points      logArr (array) : array containing historical log returns      signArr (array) : array containing historical price directions      closeArr (array) : array containing historical close points      binaryTimeArr (array) : array containing historical time points, uses "push" instead of "unshift" to allow for binary search      binaryCloseArr (array) : array containing historical close points, uses "push" instead of "unshift" to allow the correct      binaryOpenArr (array) : array containing historical optn points, uses "push" instead of "unshift" to allow the correct      atrTFarr (array) : array containing historical user-selected TF atr points      openArr (array) : array containing historical open points
Pine Script® kütüphanesi
Trading-IQ tarafından
kNNLibrary "kNN" Collection of experimental kNN functions. This is a work in progress, an improvement upon my original kNN script: The script can be recreated with this library. Unlike the original script, that used multiple arrays, this has been reworked with the new Pine Script matrix features. To make a kNN prediction, the following data should be supplied to the wrapper: kNN : filter type. Right now either Binary or Percent . Binary works like in the original script: the system stores whether the price has increased (+1) or decreased (-1) since the previous knnStore event (called when either long or short condition is supplied). Percent works the same, but the values stored are the difference of prices in percents. That way larger differences in prices would give higher scores. k : number k. This is how many nearest neighbors are to be selected (and summed up to get the result). skew : kNN minimum difference. Normally, the prediction is done with a simple majority of the neighbor votes. If skew is given, then more than a simple majority is needed for a prediction. This also means that there are inputs for which no prediction would be given (if the majority votes are between -skew and +skew). Note that in Percent mode more profitable trades will have higher voting power. depth : kNN matrix size limit. Originally, the whole available history of trades was used to make a prediction. This not only requires more computational power, but also neglects the fact that the market conditions are changing. This setting restricts the memory matrix to a finite number of past trades. price : price series long : long condition. True if the long conditions are met, but filters are not yet applied. For example, in my original script, trades are only made on crossings of fast and slow MAs. So, whenever it is possible to go long, this value is set true. False otherwise. short : short condition. Same as long , but for short condition. store : whether the inputs should be stored. Additional filters may be applied to prevent bad trades (for example, trend-based filters), so if you only need to consult kNN without storing the trade, this should be set to false. feature1 : current value of feature 1. A feature in this case is some kind of data derived from the price. Different features may be used to analyse the price series. For example, oscillator values. Not all of them may be used for kNN prediction. As the current kNN implementation is 2-dimensional, only two features can be used. feature2 : current value of feature 2. The wrapper returns a tuple: [ longOK, shortOK ]. This is a pair of filters. When longOK is true, then kNN predicts a long trade may be taken. When shortOK is true, then kNN predicts a short trade may be taken. The kNN filters are returned whenever long or short conditions are met. The trade is supposed to happen when long or short conditions are met and when the kNN filter for the desired direction is true. Exported functions : knnStore(knn, p1, p2, src, maxrows)   Store the previous trade; buffer the current one until results are in. Results are binary: up/down   Parameters:      knn : knn matrix      p1 : feature 1 value      p2 : feature 2 value      src : current price      maxrows : limit the matrix size to this number of rows (0 of no limit)   Returns: modified knn matrix knnStorePercent(knn, p1, p2, src, maxrows)   Store the previous trade; buffer the current one until results are in. Results are in percents   Parameters:      knn : knn matrix      p1 : feature 1 value      p2 : feature 2 value      src : current price      maxrows : limit the matrix size to this number of rows (0 of no limit)   Returns: modified knn matrix knnGet(distance, result)   Get neighbours by getting k results with the smallest distances   Parameters:      distance : distance array      result : result array   Returns: array slice of k results knnDistance(knn, p1, p2)   Create a distance array from the two given parameters   Parameters:      knn : knn matrix      p1 : feature 1 value      p2 : feature 2 value   Returns: distance array knnSum(knn, p1, p2, k)   Make a prediction, finding k nearest neighbours and summing them up   Parameters:      knn : knn matrix      p1 : feature 1 value      p2 : feature 2 value      k : sum k nearest neighbors   Returns: sum of k nearest neighbors doKNN(kNN, k, skew, depth, price, long, short, store, feature1, feature2)   execute kNN filter   Parameters:      kNN : filter type      k : number k      skew : kNN minimum difference      depth : kNN matrix size limit      price : series      long : long condition      short : short condition      store : store the supplied features (if false, only checks the results without storage)      feature1 : feature 1 value      feature2 : feature 2 value   Returns: filter output
Pine Script® kütüphanesi
lastguru tarafından
5
BO - RSI - M5 BacktestingBO - RSI - M5 Backtesting -Rule of Strategy A. Data 1. Chart M5 IDC 2. Symbol: EURJPY B. Indicator 1. RSI 2. Length: 12 (adjustable) 3. Extreme Top: 75 (adjustable) 4. Extreme Bottom: 25 (adjustable) C. Rule of Signal 1. Put Signal * Rsi create a temporary peak over Extreme Top row61: peak_rsi= rsi >rsi and rsi >rsi and rsi rsi_top 2. Call Signal * Rsi create a temporary bottom under Extreme Bottom row62: bott_rsi= rsi rsi and rsi <rsi_bot D. Rule of Order 1. Only 1 trade opening 2. Stoploss: No trade open after 1 loss trade each day (number of loss trades adjustable) 3. Expiry: after 6 bars (number of bars adjustable)
Pine Script® stratejisi
inno14 tarafından
2
MLLossFunctionsLibrary "MLLossFunctions" Methods for Loss functions. mse(expects, predicts) Mean Squared Error (MSE) " MSE = 1/N * sum ((y - y')^2) ".   Parameters:      expects : float array, expected values.      predicts : float array, prediction values.   Returns: float binary_cross_entropy(expects, predicts) Binary Cross-Entropy Loss (log).   Parameters:      expects : float array, expected values.      predicts : float array, prediction values.   Returns: float
Pine Script® kütüphanesi
RicardoSantos tarafından
Catalogador Binarias Padron MHI DejaVuTradesQuadrant patterns with 1 minute cataloging. This script simulates the quadrants between candles from minute 1 to 5. set your time frame to 1M. Ready, now we have our quadrants and we will do the analysis of these patterns using them. Green circles indicate winning trades, and blue circles Martingale steps. Counting candles within the quadrants (time frame m1 ) MHI There are several variants of MHI . In our cataloguer we offer 3 variants. MHI 1, 2 and 3. The analysis is carried out from the last three candles in the last quadrant. And the entry is made: on the first candle of the current quadrant ( MHI 1), on the second candle of the current quadrant ( MHI 2) and on the third candle of the current quadrant ( MHI 3). MHI 1 Entry into the first candle after the quadrant analysis. First martingale (in case of loss) in the second candle and second martingale (in case of two losses) in the third candle. MHI 2 Entry into the second candle after the quadrant analysis. First martingale (in case of loss) on the third candle and second martingale (in case of two losses) on the fourth candle. MHI 3 Entry into the third candle after the quadrant analysis. First martingale (in case of loss) on the fourth candle and second martingale (in case of two losses) on the fifth candle. The million dollar pattern It is an analysis very similar to that of the MHI , with the difference that it is in the entire quadrant. The million analysis consists of looking at all the candles in the last quadrant and entering the first candle of the current quadrant saying that that first candle will be the same color as most of the last quadrant. In cases where we have the same number of candles (3 red and 3 green) we do not trade! And the cataloger will not count these operations. Three Neighbors Pattern The analysis of the pattern of the three neighbors will always be in the third candle of the quadrant. Either in M5 or M1 . And it consists of observing the third candle and entering the following ones saying that it will be the same. Pattern C3 The C3 pattern is also an analysis in the candlestick count. We will enter the first quadrant candle saying that it will be equal to the first candle of the last quadrant. In the case of 1 martingale we will enter the third candle saying that it will be equal to the third candle of the last quadrant. And finally, in need of a second martingale, the entry will be in the fifth candle saying that it will be similar to the fifth of the last candle. Moonwalker Pattern The moonwalker pattern is also a quadrant pattern. Our entries will be in the first, second and third candles of the current quadrant. The analysis is performed on the third, second and first candle of the last quadrant. The entry of the first candle will be observed in the third candle of the last quadrant, being the opposite color to that observed. Being necessary a martingale, we make our entry into the second candle that claims the opposite color to the second candle in the last quadrant. Finally, our second martingale will be on the third candle of the current quadrant with analysis in which the color will be opposite to the first candle of the last quadrant.
Pine Script® göstergesi
DejaVuTrades_BettoLe tarafından
5
TradeMiner S9This is the first TradingView indicator EVER to include dynamic support and resistance lines from upper or lower diagonal highs and lows in real-time. Note: This indicator has been built using Pinescript V2 Like and Share for access and more awesome indicators! A blue arrow appears only in a red bar and under these conditions: Closing Score Trigger (CS < 50) On Balance Volume, Accumulation/Distribution, and Chaikin Money Flow Combination (OBV/AD /CMF > 0) Chaikin Money Flow (CMF <-0.05) A blue horizontal line will be drawn when CMF > 0.05 indicates a sale of the position. A red arrow appears only in a green bar and under these conditions: Closing Score Trigger (CS > 50) On Balance Volume, Accumulation/Distribution, and Chaikin Money Flow Combination (OBV/AD/CMF < 0) Chaikin Money Flow (CMF > 0.05) A red horizontal line will be drawn when CMF <-0.05 indicates a sale of the position. A new condition called " leaniency " has been added that allows all these conditions to be fulfilled within multiple bars so that the occurrence occurs more frequently. This will result in more signals appearing. Setting leniency to " 1 " means that all four conditions must occur in a single bar, while " 5 " means that all four conditions must occur within 5 bars. Find lifetime access to the indicator here: www.kenzing.com BTC
Pine Script® göstergesi
GrantPeace tarafından
33
B3 HL2 Method Candle PainterThis script is similar to the "Hi-Lo" or "Clear" methods of painting bars. Instead of using the tips/edges of the candles like those two, the "(H+L)/2" method uses the change in (high+low)/2 to paint the bars. This gives you some similar results if you were to be binary with the candle coloring. However, my coloring scheme is not entirely binary. There are 5 possible colors: HL2>LastHigh = Bright Green HL2LastHL2 = Dull Green HL2<LastHL2 = Dull Red Bar Change (close - open) is going against the indicator = Gray Free to share and enjoy! ~B3
Pine Script® göstergesi
HammondB3 tarafından
uranium V ☭Now everyone has free access to the script until February 18th. This script FULLY automated to open a trade by many strategies and scripts: *Bollinger Bands *RSI *Fibo levels 61.8, 78.6 *NEEW 10.0 *Zones of support from the timeframe m15 and 1h *Candle patterns This script combines 3 strategies for different open trade conditions (sometimes opens can be the same) Signals of different colors: +Pink arrows I recommend to use only at specified intervals (from 4 to 8 UTC, and from 13 to 18 UTC). Expiration should be 5 minutes. +Green arrows can be used always, but greater efficiency will be at specified intervals. Expiration should be 3 minutes. +Blue stripes are the strongest signal, they can always be used, but greater efficiency will be at the specified intervals. Expiration should be 5 minutes. For best results, I recommend opening deals on the following criteria: the indicator is superimposed on the timeframe m1 and EURUSD. +Opening trade only at the specified time, when the blue signal and the pink or green signal coincide, or the blue signal is preceded by a pink signal, open trade at the place of closing the candle of the blue signal. +Avoid strong non-characteristic price impulses, as well as news outlets. +Do not open a trade with a next pink signal bar when there is a strong pulse. +Do not open a trade with a green signal following a pink or blue signal, if the green close lowest or bigest than pink or blue signal. +Do not use martingale strategy on failure, wait for the next signal. +Use money management By adhering to these conditions.
Pine Script® göstergesi
777-5.Tonopa tarafından
31