Şimdi başlat

Mum Analizi

Replay Mode - Check Daily/WeeklyThis indicator is intended to be used while using Replay Mode. It is similar to the built-in Session Breaks, but has the benefit of not needing to remove one candle before checking the Daily. When on an intraday chart (timeframe less than Daily), a vertical line will be drawn when you can safely check the Daily or Weekly candle without seeing future price. When the line is the color of your Daily settings, it is safe to check the Daily candle. When the line is the color of your Weekly settings, it is safe to check both the Daily and Weekly candle.
Pine Script™ indikatörü
dustind59 tarafından
1
RM StratThis is my attempt to code up the rules of "The Strat." I've seen other scripts that do parts of what my script does, but this script combines all of them into one script and allows the user control over how they interact with each other. What's in this indicator? Show the Strat Candle Numbers (1 - inside bar, 2 - continuation bar, 3 - outside bar) on the chart. Show a widget off to the right of the chart for multi-timeframe analysis. This widget tells you whether the D/W/M/Q candles are currently green or red as well as the Candle type (White Circle - (1) Inside Bar, Up Green Arrow - (2U) Continuation Bar, Down Red Arrow - (2D) Continuation Bar, Green/Red Square - (3) Outside Bar) Integrates the long and short rules into the chart. These can also be turned off if you don't want to see them. Note: this is a simplified version of these rules - if you look at the cheat sheets floating around the internet, you'll notice that all trade initiations occur on a break of the high (for longs) or low (for shorts) of the previous candle as long as that previous candle was not a 2. So that's my only rule for going long or short. I think it matches well with the cheat sheets but is way simpler to code and to think of how it works. The other benefit is it shows you failed trades that the cheat sheet won't catch - where a 2 becomes a 3 in the other direction and stops you out. You'll see that now with this script. Ability to filter out the long/short rules based on the timeframe continuity of the higher timeframe candles. This is user-configurable so that you can experiment with timeframe continuity and see how strict you want to be with this on your trades. Show the high/low of the Day, Week, and Month on your chart as horizontal lines that you can use as a reference. This could be used for planning profit targets or seeing how likely a reversal might indicate moving into timeframe continuity.
Pine Script™ indikatörü
millerrh tarafından
9
Pinescript - Common Label & Line Array Functions Library by RRBPinescript - Common Label & Line Array Functions Library by RagingRocketBull 2021 Version 1.0 This script provides a library of common array functions for arrays of label and line objects with live testing of all functions. Using this library you can easily create, update, delete, join label/line object arrays, and get/set properties of individual label/line object array items. You can find the full list of supported label/line array functions below. There are several libraries: - Common String Functions Library - Standard Array Functions Library - Common Fixed Type Array Functions Library - Common Label & Line Array Functions Library - Common Variable Type Array Functions Library Features: - 30 array functions in categories create/update/delete/join/get/set with support for both label/line objects (45+ including all implementations) - Create, Update label/line object arrays from list/array params - GET/SET properties of individual label/line array items by index - Join label/line objects/arrays into a single string for output - Supports User Input of x,y coords of 5 different types: abs/rel/rel%/inc/inc% list/array, auto transforms x,y input into list/array based on type, base and xloc, translates rel into abs bar indexes - Supports User Input of lists with shortened names of string properties, auto expands all standard string properties to their full names for use in functions - Live Output for all/selected functions based on User Input. Test any function for possible errors you may encounter before using in script. - Output filters: hide all excluded and show only allowed functions using a list of function names - Output Panel customization options: set custom style, color, text size, and line spacing Usage: - select create function - create label/line arrays from lists or arrays (optional). Doesn't affect the update functions. The only change in output should be function name regardless of the selected implementation. - specify num_objects for both label/line arrays (default is 7) - specify common anchor point settings x,y base/type for both label/line arrays and GET/SET items in Common Settings - fill lists with items to use as inputs for create label/line array functions in Create Label/Line Arrays section - specify label/line array item index and properties to SET in corresponding sections - select label/line SET function to see the changes applied live Code Structure: - translate x,y depending on x,y type, base and xloc as specified in UI (required for all functions) - expand all shortened standard property names to full names (required for create/update* from arrays and set* functions, not needed for create/update* from lists) to prevent errors in label.new and line.new - create param arrays from string lists (required for create/update* from arrays and set* functions, not needed for create/update* from lists) - create label/line array from string lists (property names are auto expanded) or param arrays (requires already expanded properties) - update entire label/line array or - get/set label/line array item properties by index Transforming/Expanding Input values: - for this script to work on any chart regardless of price/scale, all x*,y* are specified as % increase relative to x0,y0 base levels by default, but user can enter abs x,price values specific for that chart if necessary. - all lists can be empty, contain 1 or several items, have the same/different lengths. Array Length = min(min(len(list*)), mum_objects) is used to create label/line objects. Missing list items are replaced with default property values. - when a list contains only 1 item it is duplicated (label name/tooltip is also auto incremented) to match the calculated Array Length - since this script processes user input, all x,y values must be translated to abs bar indexes before passing them to functions. Your script may provide all data internally and doesn't require this step. - at first int x, float y arrays are created from user string lists, transformed as described below and returned as x,y arrays. - translated x,y arrays can then be passed to create from arrays function or can be converted back to x,y string lists for the create from lists function if necessary. - all translation logic is separated from create/update/set functions for the following reasons: - to avoid redundant code/dependency on ext functions/reduce local scopes and to be able to translate everything only once in one place - should be faster - to simplify internal logic of all functions - because your script may provide all data internally without user input and won't need the translation step - there are 5 types available for both x,y: abs, rel, rel%, inc, inc%. In addition to that, x can be: bar index or time, y is always price. - abs - absolute bar index/time from start bar0 (x) or price (y) from 0, is >= 0 - rel - relative bar index/time from cur bar n (x) or price from y0 base level, is >= 0 - rel% - relative % increase of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0 - inc - relative increment (step) for each new level of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0 - inc% - relative % increment (% step) for each new level of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0 - x base level >= 0 - y base level can be 0 (empty) or open, close, high, low of cur bar - single item x1_list = "50" translates into: - for x type abs: "50, 50, 50 ..." num_objects times regardless of xloc => x = 50 - for x type rel: "50, 50, 50 ... " num_objects times => x = x_base + 50 - for x type rel%: "50%, 50%, 50% ... " num_objects times => x_base * (1 + 0.5) - for x type inc: "0, 50, 100 ... " num_objects times => x_base + 50 * i - for x type inc%: "0%, 50%, 100% ... " num_objects times => x_base * (1 + 0.5 * i) - when xloc = xloc.bar_index each rel*/inc* value in the above list is then subtracted from n: n - x to convert rel to abs bar index, values of abs type are not affected - x1_list = "0, 50, 100, ..." of type rel is the same as "50" of type inc - x1_list = "50, 50, 50, ..." of type abs/rel/rel% produces a sequence of the same values and can be shortened to just "50" - single item y1_list = "2" translates into (ragardless of yloc): - for y type abs: "2, 2, 2 ..." num_objects times => y = 2 - for y type rel: "2, 2, 2 ... " num_objects times => y = y_base + 2 - for y type rel%: "2%, 2%, 2% ... " num_objects times => y = y_base * (1 + 0.02) - for y type inc: "0, 2, 4 ... " num_objects times => y = y_base + 2 * i - for y type inc%: "0%, 2%, 4% ... " num_objects times => y = y_base * (1 + 0.02 * i) - when yloc != yloc.price all calculated values above are simply ignored - y1_list = "0, 2, 4" of type rel% is the same as "2" with type inc% - y1_list = "2, 2, 2" of type abs/rel/rel% produces a sequence of the same values and can be shortened to just "2" - you can enter shortened property names in lists. To lookup supported shortened names use corresponding dropdowns in Set Label/Line Array Item Properties sections - all shortened standard property names must be expanded to full names (required for create/update* from arrays and set* functions, not needed for create/update* from lists) to prevent errors in label.new and line.new - examples of shortened property names that can be used in lists: bar_index, large, solid, label_right, white, left, left, price - expanded to their corresponding full names: xloc.bar_index, size.large, line.style_solid, label.style_label_right, color.white, text.align_left, extend.left, yloc.price - all expanding logic is separated from create/update* from arrays and set* functions for the same reasons as above, and because param arrays already have different types, implying the use of final values. - all expanding logic is included in the create/update* from lists functions because it seemed more natural to process string lists from user input directly inside the function, since they are already strings. Creating Label/Line Objects: - use study max_lines_count and max_labels_count params to increase the max number of label/line objects to 500 (+3) if necessary. Default number of label/line objects is 50 (+3) - all functions use standard param sequence from methods in reference, except style always comes before colors. - standard label/line.get* functions only return a few properties, you can't read style, color, width etc. - label.new(na, na, "") will still create a label with x = n-301, y = NaN, text = "" because max default scope for a var is 300 bars back. - there are 2 types of color na, label color requires color(na) instead of color_na to prevent error. text_color and line_color can be color_na - for line to be visible both x1, x2 ends must be visible on screen, also when y1 == y2 => abs(x1 - x2) >= 2 bars => line is visible - xloc.bar_index line uses abs x1, x2 indexes and can only be within 0 and n ends, where n <= 5000 bars (free accounts) or 10000 bars (paid accounts) limit, can't be plotted into the future - xloc.bar_time line uses abs x1, x2 times, can't go past bar0 time but can continue past cur bar time into the future, doesn't have a length limit in bars. - xloc.bar_time line with length = exact number of bars can be plotted only within bar0 and cur bar, can't be plotted into the future reliably because of future gaps due to sessions on some charts - xloc.bar_index line can't be created on bar 0 with fixed length value because there's only 1 bar of horiz length - it can be created on cur bar using fixed length x < n <= 5000 or - created on bar0 using na and then assigned final x* values on cur bar using set_x* - created on bar0 using n - fixed_length x and then updated on cur bar using set_x*, where n <= 5000 - default orientation of lines (for style_arrow* and extend) is from left to right (from bar 50 to bar 0), it reverses when x1 and x2 are swapped - price is a function, not a line object property Variable Type Arrays: - you can't create an if/function that returns var type value/array - compiler uses strict types and doesn't allow that - however you can assign array of any type to another array of any type creating an arr pointer of invalid type that must be reassigned to a matching array type before used in any expression to prevent error - create_any_array2 uses this loophole to return an int_arr pointer of a var type array - this works for all array types defined with/without var keyword and doesn't work for string arrays defined with var keyword for some reason - you can't do this with var type vars, only var type arrays because arrays are pointers passed by reference, while vars are actual values passed by value. - you can only pass a var type value/array param to a function if all functions inside support every type - otherwise error - alternatively values of every type must be passed simultaneously and processed separately by corresponding if branches/functions supporting these particular types returning a common single type result - get_var_types solves this problem by generating a list of dummy values of every possible type including the source type, tricking the compiler into allowing a single valid branch to execute without error, while ignoring all dummy results Notes: - uses Pinescript v3 Compatibility Framework - uses Common String Functions Library, Common Fixed Type Array Functions Library, Common Variable Type Array Functions Library - has to be a separate script to reduce the number of local scopes/compiled file size, can't be merged with another library. - lets you live test all label/line array functions for errors. If you see an error - change params in UI - if you see "Loop too long" error - hide/unhide or reattach the script - if you see "Chart references too many candles" error - change x type or value between abs/rel*. This can happen on charts with 5000+ bars when a rel bar index x is passed to label.new or line.new instead of abs bar index n - x - create/update_label/line_array* use string lists, while create/update_label/line_array_from_arrays* use array params to create label/line arrays. "from_lists" is dropped to shorten the names of the most commonly used functions. - create_label/line_array2,4 are preferable, 5,6 are listed for pure demonstration purposes only - don't use them, they don't improve anything but dramatically increase local scopes/compiled file size - for this reason you would mainly be using create/update_label/line_array2,4 for list params or create/update_label/line_array_from_arrays2 for array params - all update functions are executed after each create as proof of work and can be disabled. Only create functions are required. Use update functions when necessary - when list/array params are changed by your script. - both lists and array item properties use the same x,y_type, x,y_base from common settings - doesn't use pagination, a single str contains all output - why is this so complicated? What are all these functions for? - this script merges standard label/line object methods with standard array functions to create a powerful set of label/line object array functions to simplify manipulation of these arrays. - this library also extends the functionality of Common Variable Type Array Functions Library providing support for label/line types in var type array functions (any_to_str6, join_any_array5) - creating arrays from either lists or arrays adds a level of flexibility that comes with complexity. It's very likely that in your script you'd have to deal with both string lists as input, and arrays internally, once everything is converted. - processing user input, allowing customization and targeting for any chart adds a whole new layer of complexity, all inputs must be translated and expanded before used in functions. - different function implementations can increase/reduce local scopes and compiled file size. Select a version that best suits your needs. Creating complex scripts often requires rewriting your code multiple times to fit the limits, every line matters. P.S. Don't rely too much on labels, for too often they are fables. List of functions*: * - functions from other libraries are not listed 1. Join Functions Labels - join_label_object(label_, d1, d2) - join_label_array(arr, d1, d2) - join_label_array2(arr, d1, d2, d3) Lines - join_line_object(line_, d1, d2) - join_line_array(arr, d1, d2) - join_line_array2(arr, d1, d2, d3) Any Type - any_to_str6(arr, index, type) - join_any_array4(arr, d1, d2, type) - join_any_array5(arr, d, type) 2. GET/SET Functions Labels - label_array_get_text(arr, index) - label_array_get_xy(arr, index) - label_array_get_fields(arr, index) - label_array_set_text(arr, index, str) - label_array_set_xy(arr, index, x, y) - label_array_set_fields(arr, index, x, y, str) - label_array_set_all_fields(arr, index, x, y, str, xloc, yloc, label_style, label_color, text_color, text_size, text_align, tooltip) - label_array_set_all_fields2(arr, index, x, y, str, xloc, yloc, label_style, label_color, text_color, text_size, text_align, tooltip) Lines - line_array_get_price(arr, index, bar) - line_array_get_xy(arr, index) - line_array_get_fields(arr, index) - line_array_set_text(arr, index, width) - line_array_set_xy(arr, index, x1, y1, x2, y2) - line_array_set_fields(arr, index, x1, y1, x2, y2, width) - line_array_set_all_fields(arr, index, x1, y1, x2, y2, xloc, extend, line_style, line_color, width) - line_array_set_all_fields2(arr, index, x1, y1, x2, y2, xloc, extend, line_style, line_color, width) 3. Create/Update/Delete Functions Labels - delete_label_array(label_arr) - create_label_array(list1, list2, list3, list4, list5, d) - create_label_array2(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array3(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array4(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array5(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array6(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - update_label_array2(label_arr, x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - update_label_array4(label_arr, x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array_from_arrays2(x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d) - create_label_array_from_arrays4(x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d) - update_label_array_from_arrays2(label_arr, x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d) Lines - delete_line_array(line_arr) - create_line_array(list1, list2, list3, list4, list5, list6, d) - create_line_array2(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array3(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array4(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array5(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array6(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - update_line_array2(line_arr, x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - update_line_array4(line_arr, x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array_from_arrays2(x1_arr, y1_arr, x2_arr, y2_arr, xloc_arr, extend_arr, style_arr, color_arr, width_arr, d) - update_line_array_from_arrays2(line_arr, x1_arr, y1_arr, x2_arr, y2_arr, xloc_arr, extend_arr, style_arr, color_arr, width_arr, d)
Editörün Seçtikleri
Pine Script™ indikatörü
RagingRocketBull tarafından
16
Extrema DetectorDetermines local maximums and minimums points in the chart. Parameters: lookback : number of candlesticks to look. extrema_finder_sensivity : If lower, more extreme points will be found (may over-find). Brief algorithm description: Computes a Simple Moving Average (length= extrema_finder_sensivity ), and searches for its local extremes. Given some SMA extreme, it looks the previous extrema_finder_sensivity candlesticks to find the highest (or lowest value). Notes: Is a lagged indicator: determining if the current candlestick have reach a maximum can be delayed to, at most extrema_finder_sensivity -further candlesticks.
Pine Script™ indikatörü
cryptocashcashoo tarafından
7
Gann HiLo Activator [CC]The HiLo Activator was created by W.D. Gann and I was surprised to not see more of his technical indicators on here. I will start adding more of his indicators on here if I get more interest. This is the original version of the indicator that performs like a trailing stop that also works well as a trend line. Buy when the line turns green and sell when it turns red. Let me know if there are any other indicators you want me to publish!
Pine Script™ indikatörü
cheatcountry tarafından
16
LTB Zigzag CirclesHello All, Today I am here with a new idea and script, " LTB Zigzag Circles ". The idea is to create Circles using last 2 zigzag waves and to catch the breakouts earlier than horizontal lines. if a circle is broken then the script shows entry for Long/Short positions. and if broken circle reappears again then the position is closed. You can change Zigzag period as you wish and see the different results. Here you can see how the script calculates and draws the Circles: Below you can see how the script draws part of the circle on each bar: Optionally the script can show levels: P.S. I haven't tested it as a strategy, Result and Performance may change by Zigzag period, you need to find best Zigzag period according to your strategy. By the way, my Zigzag Circles idea can be improved, if you have any recommendation let me know please ;) Enjoy!
Pine Script™ indikatörü
LonesomeTheBlue tarafından
81
Pivot Point CandlesIndicator that highlights Hammer, Inverted Hammer, Engulfing, and Harami candlestick patterns. Great for those looking for a quick way to show the most popular reversal patterns on the charts. Options will allow you to select to show Hammers, Engulfing or Harami patterns only. You choose the combinations that you want. Great tool to learn and training your eyes to the patterns. You also have an option to select "Super" versions of the Engulfing and the Harami patterns, the Supers only shows if the pattern engulfs the body and the wick of the smaller candle in the pattern. The indicator will show Bullish opportunities and Bearish opportunities on the chart for each of the patterns. The inverted hammer will show at the top indicating a Bear move, and the Hammer will show below price indicating a Bullish move. Use this indicator in conjunction with other Support & Resistance such as the simple moving averages, trend lines, flat lines, or even Bollinger bands. When these patterns show at or around these points on the chart they will indicate a reversal is pending. Wait for the next candle as confirmation that the move will actually take place in the direction indicated and you will have your pivot point on the chart and create a higher probability of success. Leverage Stochastic, RSI, or CCI indicators to help confirm the reversal as well. Look out for resistance above or support below to determine your targets for the reversal. Happy trading!
Pine Script™ indikatörü
karimka tarafından
2
MA Emperor insiliconot StrategyConverted EmperorBTC's EMA crossover indicator for easy backtesting and added ability to: Specify time period for backtesting Specify order quantity Toggle original indicators (default off) Quoting EmperorBTC: Entry is to be made when the 1. Cross over gives a P(Positive Sign) and the candle completely closes above the cross-over 2. When the Heikin Ashi turns green and the next green HA candle goes above the previous green HA candle. 3. The price should be at-least above the 0.236 Level from the Swing high. Kindly note that the strategy only attempts to do check number 1, where it ensures the entry opens above the cross-over.
Pine Script™ stratejisi
shawnteoh tarafından
36
Hammers & Stars StrategyOverview This script trades basic hammer and shooting star candlestick patterns. It's an extremely simple strategy with minimal filters, and according to my personal manual backtesting and automated trading results, performs best on the Daily chart on certain forex pairs. It is intended to be traded on the forex markets but theoretically should work on all markets (especially if you optimize the settings). The script also comes with complete AutoView automation for Oanda. Make sure you've connected AutoView to TradingView and Oanda, then simply set an alert using the "alert() function calls only" condition and it will automatically execute trades based on whatever settings you've selected (only recommended for experienced traders - use at your own risk!) If you're not sure how to set up AutoView, search "The Art of Trading AutoView Guide" on YouTube to find my detailed video guide. Check out my website and YouTube channel for more information, scripts, resources and free Pine Script & trading lessons (link in my profile). Best of luck with your trading! - Matt / The Art of Trading Settings Menu Tooltips are included explaining what the various settings do, but here's a quick summary: Strategy Settings >= ATR Filter: Minimum size of entry candle compared to ATR <= ATR Filter: Maximum size of entry candle compared to ATR Stop Loss ATR: Stop loss multiplier (x ATR) R:R: Risk:Reward profile Fib Level: Used to calculate upper/lower third of candle. (For example, setting it to 0.5 will mean hammers must close >= 50% mark of the total candle size) Start Date Filter: Date & time to begin trading from End Date Filter: Date & time to stop trading AutoView Oanda Settings Use Oanda Demo: If turned on then oandapractice broker prefix will be used for AutoView alerts (demo account). If turned off then live account will be used Use Limit Order: If turned on then AutoView will use limit orders. If turned off then market orders will be used (recommended to use limit order to mitigate spread issues) Days To Leave Limit Order: This is your GTD setting (good til day) Account Balance: Your account balance (used for calculating position size) Account Currency: Your account balance currency (used for calculating position size) Risk Per Trade %: Your risk per trade as a % of your account balance
Pine Script™ stratejisi
ZenAndTheArtOfTrading tarafından
26
MA Strategy Emperor insiliconotThe Script offers 9 different EMAs with 14 different MA types. The make use of the script is to find the entry on the 1-4 hour altcoins while using the in-built 13/21 crossover strategy to be used in sync with Heikin Ashi cross-over with Fib levels of 0.236 Fib level. How to use it. Entry is to be made when the 1. Cross over gives a P(Positive Sign) and the candle completely closes above the cross-over 2. When the Heikin Ashi turns green and the next green HA candle goes above the previous green HA candle. 3. The price should be at-least above the 0.236 Level from the Swing high. All the Best. EmperorBTC
Pine Script™ indikatörü
EmperorBTC tarafından
89
MTF SCALP Price Actionits just for personal use of my own. if you want to use this indicator, use it at your own responsibility. but just remember its a SCALP strategy and must be used on 5M timeframe. Long/Short Conditions : last 1H,30M,15M and 5M candle close on same direction. I will back test this indicator and if it worth it i will write turn it to a strategy. PS: i'm new to pinescript coding . so, sorry for my bad coding. if you have any suggestions to improve my coding skills i will be very thankful if you share it with me.
Pine Script™ indikatörü
itsleoneric tarafından
1