BinaryLibrary "Binary"
This library includes functions to convert between decimal and binary numeral formats, and logical and arithmetic operations on binary numbers.
method toBin(value)
Converts the provided boolean value into binary integers (0 or 1).
Namespace types: series bool, simple bool, input bool, const bool
Parameters:
value (bool) : The boolean value to be converted.
Returns: The converted value in binary integers.
method dec2bin(value, iBits, fBits)
Converts a decimal number into its binary representation.
Namespace types: series float, simple float, input float, const float
Parameters:
value (float) : The decimal number to be converted.
iBits (int) : The number of binary digits allocated for the integer part.
fBits (int) : The number of binary digits allocated for the fractional part.
Returns: An array containing the binary digits for the integer part at the rightmost positions and the digits for the fractional part at the leftmost positions. The array indexes correspond to the bit positions.
method bin2dec(value, iBits, fBits)
Converts a binary number into its decimal representation.
Namespace types: array
Parameters:
value (array) : The binary number to be converted.
iBits (int) : The number of binary digits allocated for the integer part.
fBits (int) : The number of binary digits allocated for the fractional part.
Returns: The converted value in decimal format.
method lgcAnd(a, b)
Bitwise logical AND of two binary numbers. The result of ANDing two binary digits is 1 only if both digits are 1, otherwise, 0.
Namespace types: array
Parameters:
a (array) : First binary number.
b (array) : Second binary number.
Returns: An array containing the logical AND of the inputs.
method lgcOr(a, b)
Bitwise logical OR of two binary numbers. The result of ORing two binary digits is 0 only if both digits are 0, otherwise, 1.
Namespace types: array
Parameters:
a (array) : First binary number.
b (array) : Second binary number.
Returns: An array containing the logical OR of the inputs.
method lgcXor(a, b)
Bitwise logical XOR of two binary numbers. The result of XORing two binary digits is 1 only if ONE of the digits is 1, otherwise, 0.
Namespace types: array
Parameters:
a (array) : First binary number.
b (array) : Second binary number.
Returns: An array containing the logical XOR of the inputs.
method lgcNand(a, b)
Bitwise logical NAND of two binary numbers. The result of NANDing two binary digits is 0 only if both digits are 1, otherwise, 1.
Namespace types: array
Parameters:
a (array) : First binary number.
b (array) : Second binary number.
Returns: An array containing the logical NAND of the inputs.
method lgcNor(a, b)
Bitwise logical NOR of two binary numbers. The result of NORing two binary digits is 1 only if both digits are 0, otherwise, 0.
Namespace types: array
Parameters:
a (array) : First binary number.
b (array) : Second binary number.
Returns: An array containing the logical NOR of the inputs.
method lgcNot(a)
Bitwise logical NOT of a binary number. The result of NOTing a binary digit is 0 if the digit is 1, or vice versa.
Namespace types: array
Parameters:
a (array) : A binary number.
Returns: An array containing the logical NOT of the input.
method lgc2sC(a)
2's complement of a binary number. The 2's complement of a binary number N with n digits is defined as 2^(n) - N.
Namespace types: array
Parameters:
a (array) : A binary number.
Returns: An array containing the 2's complement of the input.
method shift(value, direction, newBit)
Shifts a binary number in the specified direction by one position.
Namespace types: array
Parameters:
value (array)
direction (int) : The direction of the shift operation.
newBit (int) : The bit to be inserted into the unoccupied slot.
Returns: A tuple of the shifted binary number and the serial output of the shift operation.
method multiShift(value, direction, newBits)
Shifts a binary number in the specified direction by multiple positions.
Namespace types: array
Parameters:
value (array)
direction (int) : The direction of the shift operation.
newBits (array)
Returns: A tuple of the shifted binary number and the serial output of the shift operation.
method crclrShift(value, direction, count)
Circularly shifts a binary number in the specified direction by multiple positions. Each ejected bit is inserted from the opposite side.
Namespace types: array
Parameters:
value (array)
direction (int) : The direction of the shift operation.
count (int) : The number of positions to be shifted by.
Returns: The shifted binary number.
method arithmeticShift(value, direction, count)
Performs arithmetic shift on a binary number in the specified direction by multiple positions. Every new bit is 0 if the shift is leftward, otherwise, it equals the sign bit.
Namespace types: array
Parameters:
value (array)
direction (int) : The direction of the shift operation.
count (int) : The number of positions to be shifted by.
Returns: The shifted binary number.
method add(a, b, carry)
Performs arithmetic addition on two binary numbers.
Namespace types: array
Parameters:
a (array) : First binary number.
b (array) : Second binary number.
carry (int) : The input carry of the operation.
Returns: The result of the arithmetic addition of the inputs.
method sub(a, b, carry)
Performs arithmetic subtraction on two binary numbers.
Namespace types: array
Parameters:
a (array) : First binary number.
b (array) : Second binary number. The number to be subtracted.
carry (int) : The input carry of the operation.
Returns: The result of the arithmetic subtraction of the input b from the input a.
Tìm kiếm tập lệnh với "binary"
Binary_Blast_v3This is new version for binary blast! Expiry 2 candles after signal candle closes wait for signal candle to close.
QQE Cross Indicator Alert v2.0 by JustUncleLThis version of the indicator makes a distinction between the types of QQE cross alerts on the chart and now only recommends the Thresh Hold channel exit crosses for BUY/SELL alerts, the other two types of crosses are still there to provide pre-warning of pending BUY/SELL alerts. Also only the BUY/SELL alerts are filtered by Moving Average Filter and/or the new Directional filter (default). The default settings in this version have also been changed, particularly the Moving Averages, to indicate trend changes quicker.
Indicator Project Description:
*** This is a trend following indicator alert that uses fast QQE crosses with Moving Averages for trend direction filtering. QQE or Qualitative Quantitative Estimation is based on the relative strength index, but uses a smoothing technique as an additional transformation. Three crosses can be selected (all selected by default):
RSI signal crossing ZERO (XZERO)
RSI signal crossing Fast RSIatr line (XQQE)
RSI signal exiting the RSI Threshhold Channel (BUY/SELL)
The (BUY/SELL) alerts can be optionally filtered by the Moving Average Combo:
For BUY alert the Close must be above the fast MA and
fast MA (EMA8) > medium MA (EMA20) > slow MA (SMA50).
For SELL alert the Close must be below the fast MA and
fast MA (EMA8) < medium MA (EMA20) < slow MA (SMA50).
and/or Directional filter (default filter):
For BUY alert the Close must be above the slow MA (SMA50) and the directional MA (EMA20) must be green.
For SELL alert the Close must be below the slow MA (SMA50) and the directional MA (EMA20) must be red.
The XZERO and XQQE are not included in the filtering, they are used to indicate pending BUY/SELL alerts, particularly the XZERO.
Note: I have found the XQQE cross can also be quite good alert for BUY/SELL as well, particularly in direction of current trend. The XZERO I have found to be totally unreliable for BUY/SELL alerts.
This indicator should work on any currency pair, most chart timeframes and expiry in 3 to 6 candles for binary option trading. For hourly or longer charts expiry can be longer for binary options, or if available use standard forex trading techniques
Some Hints for using this indicator:
Avoid taking trades in non-trending market, this is normally indicated by a near Horizontal SMA50 line.
Avoid trading when all the moving averages are close together.
When trading 1min and 5min charts, expiry should set to 1-3 candles.
Avoid trading when market choppy, this is normally indicated by the fast EMA8 crossing the EMA20 back and forwards quickly.
High probability trades tend to occur when you get a XQQE followed by a XZERO and then BUY/SELL in the same direction of trend.
Don't trade near nor directly on any major market news (sometime better no trade day).
Please practise this system in DEMO first, before committing any real money. Be patient the more you practise the better and more confident you will be.
I hope you enjoy this indicator, it has proven very effective for me.
Black-Scholes Options Pricing ModelThis is an updated version of my "Black-Scholes Model and Greeks for European Options" indicator, that i previously published. I decided to make this updated version open-source, so people can tweak and improve it.
The Black-Scholes model is a mathematical model used for pricing options. From this model you can derive the theoretical fair value of an options contract. Additionally, you can derive various risk parameters called Greeks. This indicator includes three types of data: Theoretical Option Price (blue), the Greeks (green), and implied volatility (red); their values are presented in that order.
1) Theoretical Option Price:
This first value gives only the theoretical fair value of an option with a given strike based on the Black-Scholes framework. Remember this is a model and does not reflect actual option prices, just the theoretical price based on the Black-Scholes model and its parameters and assumptions.
2)Greeks (all of the Greeks included in this indicator are listed below):
a)Delta is the rate of change of the theoretical option price with respect to the change in the underlying's price. This can also be used to approximate the probability of your option expiring in the money. For example, if you have an option with a delta of 0.62, then it has about a 62% chance of expiring in-the-money. This number runs from 0 to 1 for Calls, and 0 to -1 for Puts.
b)Gamma is the rate of change of delta with respect to the change in the underlying's price.
c)Theta, aka "time decay", is the rate of change in the theoretical option price with respect to the change in time. Theta tells you how much an option will lose its value day by day.
d) Vega is the rate of change in the theoretical option price with respect to change in implied volatility .
e)Rho is the rate of change in the theoretical option price with respect to change in the risk-free rate. Rho is rarely used because it is the parameter that options are least effected by, it is more useful for longer term options, like LEAPs.
f)Vanna is the sensitivity of delta to changes in implied volatility . Vanna is useful for checking the effectiveness of delta-hedged and vega-hedged portfolios.
g)Charm, aka "delta decay", is the instantaneous rate of change of delta over time. Charm is useful for monitoring delta-hedged positions.
h)Vomma measures the sensitivity of vega to changes in implied volatility .
i)Veta measures the rate of change in vega with respect to time.
j)Vera measures the rate of change of rho with respect to implied volatility .
k)Speed measures the rate of change in gamma with respect to changes in the underlying's price. Speed can be used when evaluating delta-hedged and gamma hedged portfolios.
l)Zomma measures the rate of change in gamma with respect to changes in implied volatility . Zomma can be used to evaluate the effectiveness of a gamma-hedged portfolio.
m)Color, aka "gamma decay", measures the rate of change of gamma over time. This can also be used to evaluate the effectiveness of a gamma-hedged portfolio.
n)Ultima measures the rate of change in vomma with respect to implied volatility .
o)Probability of Touch, is not a Greek, but a metric that I included, which tells you the probability of price touching your strike price before expiry.
3) Implied Volatility:
This is the market's forecast of future volatility . Implied volatility is directionless, it cannot be used to forecast future direction. All it tells you is the forecast for future volatility.
How to use this indicator:
1st. Input the strike price of your option. If you input a strike that is more than 3 standard deviations away from the current price, the model will return a value of n/a.
2nd. Input the current risk-free rate.(Including this is optional, because the risk-free rate is so small, you can just leave this number at zero.)
3rd. Input the time until expiry. You can enter this in terms of days, hours, and minutes.
4th.Input the chart time frame you are using in terms of minutes. For example if you're using the 1min time frame input 1, 4 hr time frame input 480, daily time frame input 1440, etc.
5th. Pick what style of option you want data for, European Vanilla or Binary.
6th. Pick what type of option you want data for, Long Call or Long Put.
7th . Finally, pick which Greek you want displayed from the drop-down list.
*Remember the Option price presented, and the Greeks presented, are theoretical in nature, and not based upon actual option prices. Also, remember the Black-Scholes model is just a model based upon various parameters, it is not an actual representation of reality, only a theoretical one.
*Note 1. If you choose binary, only data for Long Binary Calls will be presented. All of the Greeks for Long Binary Calls are available, except for rho and vera because they are negligible.
*Note 2. Unlike vanilla european options, the delta of a binary option cannot be used to approximate the probability of the option expiring in-the-money. For binary options, if you want to approximate the probability of the binary option expiring in-the-money, use the price. The price of a binary option can be used to approximate its probability of expiring in-the-money. So if a binary option has a price of $40, then it has approximately a 40% chance of expiring in-the-money.
*Note 3. As time goes on you will have to update the expiry, this model does not do that automatically. So for example, if you originally have an option with 30 days to expiry, tomorrow you would have to manually update that to 29 days, then the next day manually update the expiry to 28, and so on and so forth.
There are various formulas that you can use to calculate the Greeks. I specifically chose the formulations included in this indicator because the Greeks that it presents are the closest to actual options data. I compared the Greeks given by this indicator to brokerage option data on a variety of asset classes from equity index future options to FX options and more. Because the indicator does not use actual option prices, its Greeks do not match the brokerage data exactly, but are close enough.
I may try to make future updates that include data for Long Binary Puts, American Options, Asian Options, etc.
Stochastic RSI StrategyThis is an an adaption of Binary option 1 minute by Maxim Chechel to a strategy. I have had success with this on FCT/BTC on Poloniex.
BB and RSI Indicator Alert v0.3 by JustUncleLI have just recently revised this indicator alert for public release. This is for the 60sec Bollinger Band break Binary Option traders.
This indicator alert is a variation of one found in a well known Broker's marketing videos. It uses Bollinger bands, RSI and moving averages. Included is a pre-warning alert condition. The strategy and settings are designed for 1min charts and Binary Options, but it could work for up to 15 min charts.
The default settings are BB(14,2) and RSI(11) with 75/25 Levels boundaries. To be a valid trade the RSI needs to be within 75/25 channel. The optional Market direction filter is enabled by default and is calculated by two EMA (200 and 50):
When 200ema rising and 50ema above 200ema then market going up.
When 200ema falling and 50ema below 200ema then market going down.
A potential Bollinger Break reversal trades identified by shapes: The purple diamond is the pre-warning purple alert and the green and red pointers with the PUT/CALL labels are the trade alerts. Make Binary Option trade in specified direction 60sec (or can also use 120sec trade without Martingale).
* Notes and Hints *
The original videos specified a Martingale money management strategy, be careful using this management. When I use Martingale I recommend go to 3 levels: 10, 25, 65 if no win at 65 stop trading this alert and start next alert back at 10, you should recovery loss by future wins given you are able to get a reasonable ITM rate with this strategy. Alternatively instead of using Martingale use 120sec Binary Option trade.
Be wary of break alerts on a steep Bollinger, they tend to keep running away for awhile, especially if steep on both sides of Bollinger channel.
As with most of this style of indicator the alert conditions will redraw until the candle is closed. For me this is okay, as it is an Alert is only to a potential trade and final decision to trade is made by me.
You need to practise this and be aware of market news, sessions boundaries, slow trading periods etc. Plan your periods of when you should trade, I prefer Asian session before lunch and London sessions.
BO_EXPIRY_VDUB_v1Set Background to custom Trading sessions & set custom Binary Options expiry times.
BO ADX Binary Option strategy based on ADX/DI cross, Put or Call at the beginning of the next candle, expire 5m for 5m candle.
Binary Options Pro Helper By Himanshu AgnihotryThe Binary Options Pro Helper is a custom indicator designed specifically for one-minute binary options trading. This tool combines technical analysis methods like moving averages, RSI, Bollinger Bands, and pattern recognition to provide precise Buy and Sell signals. It also includes a time-based filter to ensure trades are executed only during optimal market conditions.
Features:
Moving Averages (EMA):
Uses short-term (7-period) and long-term (21-period) EMA crossovers for trend detection.
RSI-Based Signals:
Identifies overbought/oversold conditions for entry points.
Bollinger Bands:
Highlights market volatility and potential reversal zones.
Chart Pattern Recognition:
Detects double tops (sell signals) and double bottoms (buy signals).
Time-Based Filter:
Trades only within specified hours (e.g., 9:30 AM to 11:30 AM) to avoid unnecessary noise.
Visual Signals:
Plots buy and sell markers directly on the chart for ease of use.
How to Use:
Setup:
Add this script to your TradingView chart and select a 1-minute timeframe.
Signal Interpretation:
Buy Signal: Triggered when EMA crossover occurs, RSI is oversold (<30), and a double bottom pattern is detected.
Sell Signal: Triggered when EMA crossover occurs, RSI is overbought (>70), and a double top pattern is detected.
Timing:
Ensure trades are executed only during the specified time window for better accuracy.
Best Practices:
Use this indicator alongside fundamental analysis or market sentiment.
Test it thoroughly with historical data (backtesting) and in a demo account before live trading.
Adjust parameters (e.g., EMA periods, RSI thresholds) based on your trading style.
Binary Signals - MnetfGives binary options signals on NASDAQ.
Signals long or short positions on the current candle in the NAS100 index.
Is mostly perfect for long entry signals
Binary Option EMA/Stoch strategyThis is new Binary Option strategy more signals are generated 60% to 65% win ratio
Binary option trading by two previous barsThis simple script uses the idea of inertia of the market. if 2 previous candles have the same color, current meant to have that too. Following this signal is equal to buying a binary option on the start of the bar (week here). Signals are shown as arrows on the series. The color of the bar shows the outcome of the current option: yellow is success, black is failure. The same outcomes are at the bottom of the chart. The blue line is the total revenue of all options so far. Can be used as template for strategy simulation.
VDUB_BINARY_PRO_3NEW UPDATED BINARY PRO 3_V2 HERE -
VDUB_BINARY_PRO_3_V1 UPGRADE from binary PRO 1 / testing/ / experimental / Trade the curves / Highs -Lows / Band cross over/ Testing using heikin ashi
//Linear Regression Curve
//Centre band
//CM_Gann Swing HighLow V2/Modified////// MA input NOT WORKING ! - I broke it :s
//Vdub_Tetris_V2/ Modified
*Update Tip /Optional
Set the centre band to '34 to run centre line
UP DOWN Indicator 1Title: UP DOWN Indicator based on ADX Strategy - Accurate Signal Provider with Enhanced Success Potential
Description:
The Martingale ADX Indicator is a groundbreaking tool meticulously crafted to offer traders unparalleled precision in signal generation and risk management. Leveraging the power of the Average Directional Index (ADX), this indicator provides 100% non-repaint signals on the current candle, guiding traders to opportune and prepare for trade entry with remarkable accuracy.
With a focus on empowering traders across various financial markets, including Forex and Binary Options, this ADX Strategy-1 Indicator introduces a unique approach to trading dynamics. By seamlessly integrating the renowned Martingale Step-1 risk management strategy, this indicator not only minimizes losses but also enhances the potential for success, even in volatile market conditions.
Key Features:
Non-Repaint Signals: The Martingale ADX Indicator stands as a testament to reliability, offering 100% non-repaint signals. Traders can trust in the consistency and not removing losing Signals which is very important to trust the previous generated signals also, eliminating uncertainties and facilitating confident decision-making.
ADX-Based Precision: Built upon the robust framework of the Average Directional Index (ADX), this indicator delivers precise signals tailored to prevailing market trends and volatility levels. Whether trading in longer timeframes or engaging in Binary Options, traders can rely on the Martingale Step-1 ADX Indicator for superior insights.
Next Candle Trading: Seamlessly integrated into trading strategies, signals from the Martingale ADX Indicator prompt action on the subsequent candle. This real-time approach ensures traders stay ahead of market movements, seizing opportunities as they emerge. Giving Signals Once Candle ahead makes traders to prepare early and decide whether they want to enter the trade on presented Signal or not as per their own experience too. If the trading candle is loss then the very next candle shall be used for taking Martingale Sep-1 to enhance the Accuracy.
Enhanced Success Potential: With Martingale Step-1 risk management, this ADX Indicator offers more than just signal accuracy – it presents the potential for heightened success rates. Through strategic position sizing and leveraging experience and Price Action insights, traders can elevate overall accuracy to levels ranging from 80% to 90%.
Conclusion:
The UP DOWN Strategy-1 Indicator represents a paradigm shift in trading technology, combining precision signal generation with advanced risk management strategies. Whether you're a seasoned trader or just starting your journey, this indicator empowers you to navigate financial markets with confidence and achieve consistent results.
Experience the difference with the Martingale ADX Indicator – where reliability meets profitability, and success becomes attainable with every trade.
Trade wisely, and may your ventures be marked by prosperity and fulfillment.
Pardon for any descriptive language grammatical error and comment about this indicator and to get my other strategy as well. Happy trading !!
Risk Disclaimer:
Trading in financial markets carries inherent risks and should be approached with caution. It is imperative to exercise sound judgment and trade only with funds that you can afford to lose. We strongly advise against using borrowed funds for trading purposes. First practice on demo for own learning then make decision wisely.
Bitwise, Encode, DecodeLibrary "Bitwise, Encode, Decode"
Bitwise, Encode, Decode, and more Library
docs()
Hover-Over Documentation for inside Text Editor
bAnd(a, b)
Returns the bitwise AND of two integers
Parameters:
a : `int` - The first integer
b : `int` - The second integer
Returns: `int` - The bitwise AND of the two integers
bOr(a, b)
Performs a bitwise OR operation on two integers.
Parameters:
a : `int` - The first integer.
b : `int` - The second integer.
Returns: `int` - The result of the bitwise OR operation.
bXor(a, b)
Performs a bitwise Xor operation on two integers.
Parameters:
a : `int` - The first integer.
b : `int` - The second integer.
Returns: `int` - The result of the bitwise Xor operation.
bNot(n)
Performs a bitwise NOT operation on an integer.
Parameters:
n : `int` - The integer to perform the bitwise NOT operation on.
Returns: `int` - The result of the bitwise NOT operation.
bShiftLeft(n, step)
Performs a bitwise left shift operation on an integer.
Parameters:
n : `int` - The integer to perform the bitwise left shift operation on.
step : `int` - The number of positions to shift the bits to the left.
Returns: `int` - The result of the bitwise left shift operation.
bShiftRight(n, step)
Performs a bitwise right shift operation on an integer.
Parameters:
n : `int` - The integer to perform the bitwise right shift operation on.
step : `int` - The number of bits to shift by.
Returns: `int` - The result of the bitwise right shift operation.
bRotateLeft(n, step)
Performs a bitwise right shift operation on an integer.
Parameters:
n : `int` - The int to perform the bitwise Left rotation on the bits.
step : `int` - The number of bits to shift by.
Returns: `int`- The result of the bitwise right shift operation.
bRotateRight(n, step)
Performs a bitwise right shift operation on an integer.
Parameters:
n : `int` - The int to perform the bitwise Right rotation on the bits.
step : `int` - The number of bits to shift by.
Returns: `int` - The result of the bitwise right shift operation.
bSetCheck(n, pos)
Checks if the bit at the given position is set to 1.
Parameters:
n : `int` - The integer to check.
pos : `int` - The position of the bit to check.
Returns: `bool` - True if the bit is set to 1, False otherwise.
bClear(n, pos)
Clears a particular bit of an integer (changes from 1 to 0) passes if bit at pos is 0.
Parameters:
n : `int` - The integer to clear a bit from.
pos : `int` - The zero-based index of the bit to clear.
Returns: `int` - The result of clearing the specified bit.
bFlip0s(n)
Flips all 0 bits in the number to 1.
Parameters:
n : `int` - The integer to flip the bits of.
Returns: `int` - The result of flipping all 0 bits in the number.
bFlip1s(n)
Flips all 1 bits in the number to 0.
Parameters:
n : `int` - The integer to flip the bits of.
Returns: `int` - The result of flipping all 1 bits in the number.
bFlipAll(n)
Flips all bits in the number.
Parameters:
n : `int` - The integer to flip the bits of.
Returns: `int` - The result of flipping all bits in the number.
bSet(n, pos, newBit)
Changes the value of the bit at the given position.
Parameters:
n : `int` - The integer to modify.
pos : `int` - The position of the bit to change.
newBit : `int` - na = flips bit at pos reguardless 1 or 0 | The new value of the bit (0 or 1).
Returns: `int` - The modified integer.
changeDigit(n, pos, newDigit)
Changes the value of the digit at the given position.
Parameters:
n : `int` - The integer to modify.
pos : `int` - The position of the digit to change.
newDigit : `int` - The new value of the digit (0-9).
Returns: `int` - The modified integer.
bSwap(n, i, j)
Switch the position of 2 bits of an int
Parameters:
n : `int` - int to manipulate
i : `int` - bit pos to switch with j
j : `int` - bit pos to switch with i
Returns: `int` - new int with bits switched
bPalindrome(n)
Checks to see if the binary form is a Palindrome (reads the same left to right and vice versa)
Parameters:
n : `int` - int to check
Returns: `bool` - result of check
bEven(n)
Checks if n is Even
Parameters:
n : `int` - The integer to check.
Returns: `bool` - result.
bOdd(n)
checks if n is Even if not even Odd
Parameters:
n : `int` - The integer to check.
Returns: `bool` - result.
bPowerOfTwo(n)
Checks if n is a Power of 2.
Parameters:
n : `int` - number to check.
Returns: `bool` - result.
bCount(n, to_count)
Counts the number of bits that are equal to 1 in an integer.
Parameters:
n : `int` - The integer to count the bits in.
to_count `string` - the bits to count
Returns: `int` - The number of bits that are equal to 1 in n.
GCD(a, b)
Finds the greatest common divisor (GCD) of two numbers.
Parameters:
a : `int` - The first number.
b : `int` - The second number.
Returns: `int` - The GCD of a and b.
LCM(a, b)
Finds the least common multiple (LCM) of two integers.
Parameters:
a : `int` - The first integer.
b : `int` - The second integer.
Returns: `int` - The LCM of a and b.
aLCM(nums)
Finds the LCM of an array of integers.
Parameters:
nums : `int ` - The list of integers.
Returns: `int` - The LCM of the integers in nums.
adjustedLCM(nums, LCM)
adjust an array of integers to Least Common Multiple (LCM)
Parameters:
nums : `int ` - The first integer
LCM : `int` - The second integer
Returns: `int ` - array of ints with LCM
charAt(str, pos)
gets a Char at a given position.
Parameters:
str : `string` - string to pull char from.
pos : `int` - pos to get char from string (left to right index).
Returns: `string` - char from pos of string or "" if pos is not within index range
decimalToBinary(num)
Converts a decimal number to binary
Parameters:
num : `int` - The decimal number to convert to binary
Returns: `string` - The binary representation of the decimal number
decimalToBinary(num, to_binary_int)
Converts a decimal number to binary
Parameters:
num : `int` - The decimal number to convert to binary
to_binary_int : `bool` - bool to convert to int or to string (true for int, false for string)
Returns: `string` - The binary representation of the decimal number
binaryToDecimal(binary)
Converts a binary number to decimal
Parameters:
binary : `string` - The binary number to convert to decimal
Returns: `int` - The decimal representation of the binary number
decimal_len(n)
way of finding decimal length using arithmetic
Parameters:
n `float` - floating decimal point to get length of.
Returns: `int` - number of decimal places
int_len(n)
way of finding number length using arithmetic
Parameters:
n : `int`- value to find length of number
Returns: `int` - lenth of nunber i.e. 23 == 2
float_decimal_to_whole(n)
Converts a float decimal number to an integer `0.365 to 365`.
Parameters:
n : `string` - The decimal number represented as a string.
Returns: `int` - The integer obtained by removing the decimal point and leading zeroes from s.
fractional_part(x)
Returns the fractional part of a float.
Parameters:
x : `float` - The float to get the fractional part of.
Returns: `float` - The fractional part of the float.
form_decimal(a, b, zero_fix)
helper to form 2 ints into 1 float seperated by the decimal
Parameters:
a : `int` - a int
b : `int` - b int
zero_fix : `bool` - fix for trailing zeros being truncated when converting to float
Returns: ` ` - float = float decimal of ints | string = string version of b for future use to ref length
bEncode(n1, n2)
Encodes two numbers into one using bit OR. (fastest)
Parameters:
n1 : `int` - The first number to Encodes.
n2 : `int` - The second number to Encodes.
Returns: `int` - The result of combining the two numbers using bit OR.
bDecode(n)
Decodes an integer created by the bCombine function.(fastest)
Parameters:
n : `int` - The integer to decode.
Returns: ` ` - A tuple containing the two decoded components of the integer.
Encode(a, b)
Encodes by seperating ints into left and right of decimal float
Parameters:
a : `int` - a int
b : `int` - b int
Returns: `float` - new float of encoded ints one on left of decimal point one on right
Decode(encoded)
Decodes float of 2 ints seperated by decimal point
Parameters:
encoded : `float` - the encoded float value
Returns: ` ` - tuple of the 2 ints from encoded float
encode_heavy(a, b)
Encodes by combining numbers and tracking size in the
decimal of a floating number (slowest)
Parameters:
a : `int` - a int
b : `int` - b int
Returns: `float` - new decimal of encoded ints
decode_heavy(encoded)
Decodes encoded float that tracks size of ints in float decimal
Parameters:
encoded : `float` - encoded float
Returns: ` ` - tuple of decoded ints
decimal of float (slowest)
Parameters:
encoded : `float` - the encoded float value
Returns: ` ` - tuple of the 2 ints from encoded float
Bitwise, Encode, Decode Docs
In the documentation you may notice the word decimal
not used as normal this is because when referring to
binary a decimal number is a number that
can be represented with base 10 numbers 0-9
(the wiki below explains better)
A rule of thumb for the two integers being
encoded it to keep both numbers
less than 65535 this is because anything lower uses 16 bits or less
this will maintain 100% accuracy when decoding
although it is possible to do numbers up to 2147483645 with
this library doesnt seem useful enough
to explain or demonstrate.
The functions provided work within this 32-bit range,
where the highest number is all 1s and
the lowest number is all 0s. These functions were created
to overcome the lack of built-in bitwise functions in Pinescript.
By combining two integers into a single number,
the code can access both values i.e when
indexing only one array index
for a matrices row/column, thus improving execution time.
This technique can be applied to various coding
scenarios to enhance performance.
Bitwise functions are a way to use integers in binary form
that can be used to speed up several different processes
most languages have operators to perform these function such as
`<<, >>, &, ^, |, ~`
en.wikipedia.org
Two Bar Break Line Alerts R1.0 by JustUncleLThis indicator with default settings is designed for BINARY OPTIONS trading. The indicator can also be used for Forex trading with some setting changes. The script shows Two Bar Pullback Break lines and alerts when those Break lines are Touched (broken) creating a short term momentum entry condition.
For a Bullish Break (Green Up Arrow) to occur: first must have two (or three) consecutive bear (red) candles which is followed by a bull (green) candle creating a pivot point. The breakout occurs then the High of the current Bull (green) exceeds the highest point of the previous two (or three) pivotal bear candles. The green channel Line shows where the current Bullish BreakOut occurs.
For a Bearish Break (Red Down Arrow) to occur: first must have two (or three) consecutive bull (green) candles which is followed by a bear (red) candle creating a pivot point. The breakout occurs when the Low of the current Bear (red) drops below the lowest point of the previous two (or three) pivotal Bull candles. The red channel Line shows where the current Bearish BreakOut occurs.
The break Line Arrows can optionally be filtered by the Coloured MA (enabled by default), a longer term directional MA (disabled by default) and/or a MACD condition (enabled by default) as a momentum filter.
You can optionally select three Bar break lines instead of two. The three bar break lines are actually equivalent to Guppy's Three Bar Count Back Line method for trade entries (see Guppy's video reference below).
Included in this indicator is an ability to display some basic Binary Option statistics, when enabled (enabled by default) it shows Successful Bars in Yellow and failed Bars in Black and the last Nine numbers on the script title line represent the Binary option Statistics in order:
%ITM rate
Total orders
Successful Orders
Failed Orders
Total candles tested
Candles per Day
Trades per Day
Max Consecutive Wins
Max Consecutive Losses
You can start the Binary Option statistics from a specific Date, which is handy for checking more recent history.
HINTS:
BINARY OPTIONS trading: use 5min, 15m, 1hr or even Daily charts. Trade after the price touches one of the Breakout lines and the Arrow first appears. Wait for the price to come back from Break Line by 1 or 2 pips, the alert arrow must stay on and candle change to black, then take Binary trade expiry End of Candle. If price pull back and arrow turns off, don't trade this candle, move on you probably don't have momentum, there will be plenty of other trigger events. The backtesting results are good with ITM rates 65% to 72% on many currency pairs, commodities and indices. Realtime trading has confirmed the backtesting results and they could even be bettered, provided you are selective on which signals to trade (strong MACD support etc), that you are patient and disciplined to this trading method.
FOREX trading: the default settings should work with scalping. For longer term trades try with settings change to a more standard MACD filter or slower to catch the longer term momentum swings and the idea would be to trade the first Break Line alert that occurs after a decent Pullback in the direction of the trend. Setting the SL to just above/below the Pivot High/Low and set target to two or three times SL.
References:
"Fundamentals of Price Action Trading for Forex, Stocks, Options and Futures" video:
www.youtube.com
Other videos by "basecamptrading" on Naked Trading.
"Taking Profits in Today's Market by Daryl Guppy" video:
www.youtube.com
Bernoulli Process - Binary Entropy FunctionThis indicator is the Bernoulli Process or Wikipedia - Binary Entropy Function . Within Information Theory, Entropy is the measure of available information, here we use a binary variable 0 or 1 (P) and (1-P) (Bernoulli Function/Distribution), and combined with the Shannon Entropy measurement. As you can see below, it produces some wonderful charts and signals, using price, volume, or both summed together. The chart below shows you a couple of options and some critical details on the indicator. The best part about this is the simplicity, all of this information in a couple of lines of code.
Using the indicator:
The longer the Entropy measurement the more information you are capturing, so the analogy is, the shorter the signal, the less information you have available to utilize. You'll run into your Nyquist frequencies below a length of 5. I've found values between 9 and 22 work well to gather enough measurements. You also have an averaging summation that measures the weight or importance of the information over the summation period. This is also used for highlighting when you have an information signal above the 5% level (2 sigma) and then can be adjusted using the Percent Rank Variable. Finally, you can plot the individual signals (Price or Volume) to get another set of measurements to utilize. As can be seen in the chart below, the volume moves before price (but hopefully you already knew that)
At its core, this is taking the Binary Entropy measurement (using a Bernoulli distribution) for price and volume. I've subtracted the volume from the price so that you can use it like a MACD, also for shorter time frames (7, 9, 11) you can get divergences on the histogram. These divergences are primarily due to the weekly nature of the markets (5 days, 10 days is two weeks,...so 9 is measuring the last day of the past two weeks...so 11 is measuring the current day and the past two weeks).
Here are a couple of other examples, assuming you just love BTC, Stocks, or FOREX. I fashioned up a strategy to show the potential of the indicator.
BTC-Strategy
Stock-Strategy (#loveyouNFLX)
FOREX - (for everyone hopped up on 40X leverage)
Ivan Gomes StrategyIG Signals+ - Ivan Gomes Strategy
This script is designed for scalping and binary options trading, generating buy and sell signals at the beginning of each candle. Although it is mainly optimized for short-term operations, it can also be used for medium and long-term strategies with appropriate adjustments.
How It Works
• The indicator provides buy or sell signals at the start of the candle, based on a statistical probability of candle patterns, depending on the timeframe.
• It is essential to enter the trade immediately after the signal appears and exit at the end of the same candle.
• If the first operation results in a loss (Loss), the script will send another trade signal at the start of the next candle. However, if the first trade results in a win (Gain), no new signal will be generated.
• The signals follow cycles of 3 candles, regardless of the timeframe. However, if a Doji candle appears, the cycle is interrupted, and no signals will be generated until the next valid cycle starts.
• The strategy consists of up to two trades per cycle: if the first trade is not successful, the second trade serves as an additional attempt to recover.
Key Points to Consider
1. Avoid trading in sideways markets – If price levels do not fluctuate significantly, the accuracy of the signals may decrease.
2. Trade in the direction of the trend – Using Ichimoku clouds or other trend indicators can help confirm trend direction and improve signal reliability. If the market is in an uptrend (bullish trend) and the indicator generates a sell signal, the most prudent decision would be to wait for a buy signal that aligns with the main trend. The same applies to downtrends, where buy signals may be riskier.
These decisions should be based on chart reading and supported by other technical analysis tools, such as support and resistance levels, which indicate zones where price might face obstacles or reverse direction. Additionally, Fibonacci retracement levels can help identify possible pullback points within a trend. Moving averages are also useful for visualizing the general market direction and confirming whether an indicator signal aligns with the overall price structure. Combining these tools can increase trade accuracy and prevent unnecessary trades against the main trend, reducing risks.
3. Works based on probability statistics – The algorithm analyzes candle formations and their statistical probabilities depending on the timeframe to optimize trade entries.
4. Best suited for scalping and binary options – This strategy performs best in 1-minute and 5-minute timeframes, allowing for multiple trades throughout the day.
Technical Details
• The script detects the candle cycle and assigns an index to each candle to identify patterns and possible reversals.
• It recognizes reference candles, stores their colors, and compares them with subsequent candles to determine if a signal should be triggered.
• Doji candle rules are implemented to avoid false signals in indecisive market conditions. When a Doji appears, the script does not generate signals for that cycle.
• The indicator displays visual alerts and notifications, ensuring fast execution of trades.
Disclaimer
The IG Signals+ indicator was created to assist traders who struggle to analyze the market by providing objective trade signals. However, no strategy is foolproof, and this script does not guarantee profits.
Trading involves significant financial risk, and users should test it in a demo account before trading with real money. Proper risk management is crucial for long-term success.
vdubsoxI've been asking for this concept for a while, a simple MA that rides the top side of the trend instead of the bottom, and by accident came across the 'Hull ma' on a TV blog post. I've added another two simple Moving averages to act as strength indicator with close proximity to the price.
The strategy is simple MA cross over but with the early indication using Hull ma gives you a heads up on trend / price reversal.
I'm using this in conjunction with BB set at 34. on a 1/3/5 min charts & Heiken Ashi to smooth out the noise with awesome success trading Binary options.
BO - CCI Arrow with AlertBO - CCI Arrow with Alert base on CCI indicator to get signal for trade Binary Option.
Rules of BO - CCI Arrow with Alert below:
A. Setup Menu
1. cciLength:
* Default CCI lenght = 14
2. Linear Regression Length:
* Periods to calculate Linear Regression of CCI,
* Default value = 5
3. Extreme Level:
* Default top extreme level = 100
* Default bottom extreme level = -100
4. Filter Length:
* Periods to define highest or lowest Linear Regression
* Default value = 6
B. Rule Of Alert Bar
1. Put Alert Bar
* Current Linear Regression Line created temporrary peak
* Peak of Linear Regression Line greater than Top Extreme Level (100)
* Previous Linear Regression is highest of Filter Length (6)
* Previous Linear Regression is greater than previous peak of Linear Regression Line
* Current price greater than previous low
* CCI(14) less than Linear Regression Line
2. Call Alert Bar
* Current Linear Regression Line created temporrary bottom
* Bottom of Linear Regression Line less than Bottom Extreme Level (-100)
* Previous Linear Regression is lowest of Filter Length (6)
* Previous Linear Regression is less than previous bottom of Linear Regression Line
* Current price less than previous lhigh
* CCI(14) greater than Linear Regression Line
B. Rule Of Entry Bar and Epiry.
1. Put Entry with expiry 3 bars:
* After Put Alert Bar close with signal confirmed, put Arrow appear, and after 3 bars, result label will appear to show win trade, loss trade or draw trade
2. Call Entry with expiry 3 bars:
* After Call Alert Bar close with signal confirmed, call Arrow appear, and after 3 bars, result label will appear to show win trade, loss trade or draw trade.
3. While 1 trade is opening no more any signal
C. Popup Alert/Mobile Alert
1. Signal alert: Put Alert or Call Alert will send to mobile or show popup on chart
2. Put Alert: only Put Alert will send to mobile or show popup on chart
3. Call Alert: only Call Alert will send to mobile or show popup on chart
BO - Bar M15 2/3 SignalBO - Bar M15 2/3 Signal show the signal to trade Binary Option with rule below:
A. Indicator
* Bollinger Band (20,2): avoid waterfall
B. Rule of Signal
1. Rule1: Split Bar M15 to 3 part and load them on M5 chart (recommend use M5 IDC chart)
2. Rule 2: Delay 10' after bar M15 open => wait for price's pattern
3. Rule 3: Put Signal row 30-32
* Delay 10' after bar M15 open.
* Direction of 1/3 and 2/3 Bar M15 is upward
* close of 2/3 Bar M15 below upper band Bb(20,2) on M5 chart => avoid strong buy
4. Rule 4: Call Signal row 36-38
* Delay 10' after bar M15 open.
* Direction of 1/3 and 2/3 Bar M15 is downward
* close of 2/3 Bar M15 above lower band Bb(20,2) on M5 chart => avoid strong sell
C. Recommend Expiry time: Bar M15 close
* We try to catch the shadow of Bar M15 but dont trade when price run on the upper or lower band of BB(20,2,M5)
BO - Bar M15 Signal* This script show the signal base on volatility of previous bar M15 to trade Binary Option.
* Rule of Signal is below:
A. Rule 1: Wait for prices created temporary peak and bottom
Row 18: 10 minutes till close
B. Rule 2: Reversal previous bar's direction
1. Put Signal - Row 22 - 25:
- Delay 5' after bar M15 open
- previous bar's direction is upward
- price less than previous close
- temporary bottom greater than previous open
2. Call Signal - Row 29 - 32:
- Delay 5' after bar M15 open
- previous bar's direction is downward
- price greater than previous close
- temporary peak less than previous open
C. Rule 3: Follow previous bar's direction
1. Put Signal - Row 37 - 40:
- Delay 5' after bar M15 open
- previous bar's direction is downward
- price greater than previous open
- temporary peak less than previous peak
2. Call Signal - Row 43 - 46:
- Delay 5' after bar M15 open
- previous bar's direction is upward
- price less than previous open
- temporary bottom greater than previous bottom
