BRINOVS blocks: Analysis (25 to 33)

The Analysis blocks look at the past of the market and measure it. They count digits, measure how big the price moves are, read a trend from moving averages, spot named candle shapes and count how many of your conditions are true. They give back numbers, lists, words or yes and no.

Please read this once. Every one of these blocks describes what already happened. None of them predicts the next tick, the next candle or the result of your trade, and none of them makes a win more likely. They are tools for building your own rules, and you should test any rule on a demo account first.

A few words first. A tick is one new price from the market. A candle is a bar that sums up the price over a fixed time, with an open, a high, a low and a close. The last digit of a price is its final figure, read with the market's own number of decimals, so 876.50 has the last digit 0. A window is how many of the latest ticks or candles a block looks at.

You find these blocks in the BRINOVS menu, in the folder "Analysis". They can be plugged in anywhere a number, a word or a true/false is wanted, most often inside an if in "2. Purchase conditions". If a block cannot answer (too little data, a gap in the data, or the data cannot be read), it does not guess. Number blocks give "not a number", true/false blocks give false, and word blocks say NOT_READY or UNKNOWN. The candle blocks use only closed candles, never the one still forming.

Digit frequency

• Kind: BRINOVS custom, block #25
• Type id: bnv_digit_frequency
• Shape: Value block (gives a number, a list, or a true/false, depending on your choice)
• Where it goes: Anywhere a value is wanted.
• What it does: Counts how often each last digit (0 to 9) showed up in the latest ticks of the market the bot trades. It replaces the ten-variable counting loop people used to build by hand.
• Inputs:
  • Digit frequency over the last [ 1000 ] ticks: a whole number from 1 to 1000, default 1000. A bigger number is cut to 1000 and the journal says so.
  • give me: [ the % of one digit ▾ ] (default), [ the list of 10 percentages (digit 0 to 9) ▾ ], [ the number of ticks counted ▾ ] or [ true when the window is full ▾ ]
  • digit: a number from 0 to 9, default 0. It is used only for "the % of one digit".
• Gives back: a percentage, a list of ten percentages (digit 0 first), a count of ticks, or true/false.
• How it works: The bot takes the tick history it keeps for the traded market (at most the latest 1000 ticks) and counts the last digits. Percentages are shares of the ticks counted, with two decimals. Until the window is full, the percentages cover the ticks known so far. "The number of ticks counted" tells you how many, and "true when the window is full" is the warm-up flag.
• Example:

┌─ 2. Purchase conditions ─────────────────────────────┐
│ if  < ( Digit frequency over the last [ 1000 ] ticks │
│         give me [ the % of one digit ▾ ]             │
│         digit [ 7 ] ) < [ 8 ] >                      │
│ then  Purchase [ Over ▾ ]                            │
└──────────────────────────────────────────────────────┘

The bot buys only when the digit 7 made up less than 8 percent of the last 1000 ticks. This is a count of the past.

• Good to know:
  • Refusals: a window that is not a whole number of 1 or more; no choice of what to give back; a digit that is not a whole number from 0 to 9; tick history not available in this bot.
  • If the history or the market's decimals cannot be read, there is no answer (not a number, 0 or false) and the journal says why.
  • It is a descriptive statistic. On synthetic indices the past frequency of a digit may not predict the next digit.

Digit extremes

• Kind: BRINOVS custom, block #26
• Type id: bnv_digit_extremes
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted.
• What it does: Finds the most frequent or least frequent last digit in the latest ticks, or the second, third and so on. It can give you the digit or its percentage.
• Inputs:
  • The [ most ▾ ] frequent digit, place [ 1 ]: most (default) or least; the place is a whole number from 1 to 10, default 1
  • over the last [ 1000 ] ticks: a whole number from 1 to 1000, default 1000
  • a tie goes to: [ the lower digit ▾ ] (default) or [ the digit seen most recently ▾ ]
  • give me: [ the digit ▾ ] (default) or [ its % ▾ ]
• Gives back: the digit (0 to 9) or its percentage. "Not a number" until the window is full.
• How it works: It counts the last digits like the Digit frequency block and ranks the ten digits. Place 1 is the top of the ranking, place 2 the next one, and so on up to 10. When two digits have the same count, your tie rule decides.
• Example:

┌─ 2. Purchase conditions ───────────────────────────┐
│ if  < ( The [ most ▾ ] frequent digit, place [ 1 ] │
│         over the last [ 1000 ] ticks               │
│         a tie goes to [ the lower digit ▾ ]        │
│         give me [ the digit ▾ ] ) = [ 3 ] >        │
│ then  Purchase [ Differs ▾ ]                       │
└────────────────────────────────────────────────────┘

The bot buys only when the most common last digit of the last 1000 ticks is 3.

• Good to know:
  • Refusals: no most or least chosen; a place that is not a whole number from 1 to 10; no tie rule; no choice of what to give back; a window that is not a whole number of 1 or more.
  • Until the window is full there is no answer. The journal says how many ticks are known.
  • It is a descriptive statistic. A digit being "hot" in the past does not mean it will come again.

Digit transition

• Kind: BRINOVS custom, block #27
• Type id: bnv_digit_transition
• Shape: Value block (gives a number or a true/false, depending on your choice)
• Where it goes: Anywhere a value is wanted.
• What it does: Tells you how often one last digit was followed by another one in the latest ticks. For example: of all the times a 4 appeared, in what share of cases did the next tick end in a 7?
• Inputs:
  • How often digit [ 0 ] is followed by digit [ 1 ]: two numbers from 0 to 9, defaults 0 and 1
  • over the last [ 1000 ] ticks: a whole number from 1 to 1000, default 1000
  • give me: [ the % ▾ ] (default), [ times the first digit was counted ▾ ], [ true when that is under 30 (a small sample) ▾ ] or [ true when the window is full ▾ ]
• Gives back: a percentage, a count, or true/false.
• How it works: The bot looks at every time the first digit appeared and had a tick after it. The percentage is the share of those times where the next tick ended in the second digit. If the first digit never had a tick after it, there is no answer.
• Example:

┌─ 2. Purchase conditions ─────────────────────────────────┐
│ if  < ( How often digit [ 4 ] is followed by digit [ 7 ] │
│         over the last [ 1000 ] ticks                     │
│         give me [ the % ▾ ] ) ≥ [ 12 ] >                 │
│ then  Purchase [ Matches ▾ ]                             │
└──────────────────────────────────────────────────────────┘

The bot buys only when, in the last 1000 ticks, a 4 was followed by a 7 in at least 12 percent of the cases.

• Good to know:
  • Refusals: a first or second digit that is not a whole number from 0 to 9; no choice of what to give back; a window that is not a whole number of 1 or more.
  • Under 30 times counted is a small sample. The percentage is then very uncertain, and the journal warns once.
  • Until the window is full the percentage is "not a number".
  • It is a descriptive statistic and does not predict the next digit.

Volatility gate

• Kind: BRINOVS custom, block #28
• Type id: bnv_volatility_gate
• Shape: True/false block
• Where it goes: In an if inside "2. Purchase conditions".
• What it does: Says yes when the market's volatility is inside the range you set. Volatility means how much the price moves around. It says nothing about which way the price will go.
• Inputs:
  • Volatility is normal: measure: [ ATR (average true range) ▾ ] (default), [ standard deviation of returns ▾ ] or [ average tick move ▾ ]
  • over the last [ 14 ] candles or ticks: a whole number from 2 to 200, default 14
  • normal range from [ 0 ] to [ 1 ]: two numbers of 0 or more, minimum first. The defaults are only placeholders.
  • candle size: [ 1 minute ▾ ] (default) and others up to 1 day. It is not used by the average tick move.
• Gives back: true when the value is from your minimum to your maximum (both included). False when it is below, above, or not known.
• How it works: ATR is the average size of a candle, in price units. The standard deviation of returns (how much the closes jump from candle to candle) and the average tick move are in percent. Only closed candles are used. A missing candle inside the data, or too few candles, gives no answer.
• Example:

┌─ 2. Purchase conditions ────────────────────────────────────┐
│ if  < Volatility is normal: measure [ average tick move ▾ ] │
│       over the last [ 50 ] candles or ticks                 │
│       normal range from [ 0.01 ] to [ 0.05 ]                │
│       candle size [ 1 minute ▾ ]                            │
│       (not used by the tick move) >                         │
│ then  Purchase [ Rise ▾ ]                                   │
└─────────────────────────────────────────────────────────────┘

The bot buys only while the average tick move of the last 50 ticks is between 0.01 and 0.05 percent.

• Good to know:
  • Refusals: no method chosen; a lookback that is not a whole number from 2 to 200; a minimum or maximum below 0; a minimum above the maximum; a candle size not from the list.
  • The right range is different for every market and candle size. Set it for yours.
  • It comes with a companion value block, "Volatility value" (bnv_volatility_value). It has the same settings and gives back the number itself, or the state LOW, NORMAL, HIGH or NOT_READY.

Volatility value

• Kind: BRINOVS custom, companion of block #28
• Type id: bnv_volatility_value
• Shape: Value block (gives a number or a word)
• Where it goes: Anywhere a value is wanted. Use the same settings as your Volatility gate.
• What it does: Gives you the number that the Volatility gate looks at, or its state. It is handy when you want to compare the volatility yourself.
• Inputs:
  • measure, lookback, normal range and candle size: the same as in the Volatility gate, with the same defaults (ATR, 14, 0 to 1, 1 minute)
  • give me: [ the value ▾ ] (default) or [ the state (LOW / NORMAL / HIGH) ▾ ]
• Gives back: the volatility number, or one of LOW (under your minimum), NORMAL, HIGH (over your maximum) or NOT_READY (not known).
• How it works: It works out the same value as the gate, with the same rules for closed candles and missing data, and then returns either the value or the state.
• Example:

┌─ 2. Purchase conditions ─────────────────────────┐
│ if  < ( Volatility value: measure                │
│         [ ATR (average true range) ▾ ]           │
│         over the last [ 14 ] candles or ticks    │
│         normal range from [ 0.2 ] to [ 1.5 ]     │
│         candle size [ 5 minutes ▾ ]              │
│         (not used by the tick move)              │
│         give me [ the state ▾ ] ) = [ NORMAL ] > │
│ then  Purchase [ Over ▾ ]                        │
└──────────────────────────────────────────────────┘

The bot buys only when the ATR of the 5-minute candles is in the normal range.

• Good to know:
  • It has the same refusals as the Volatility gate, plus one more: no choice of what to give back.
  • Volatility says nothing about direction.

Multi-timeframe bias

• Kind: BRINOVS custom, block #29
• Type id: bnv_multi_timeframe_bias
• Shape: Value block (gives a word: UP, DOWN, NEUTRAL or NOT_READY)
• Where it goes: Anywhere a value is wanted, for example in a comparison inside an if.
• What it does: Reads the usual "bias" of a candle size by comparing a fast moving average with a slow one. It is meant for a bigger candle size than the one you trade with, to give a wider picture of the past.
• Inputs:
  • Bias on the [ 1 minute ▾ ] candles: a size from 1 minute up to 1 day, default 1 minute
  • fast average [ 9 ] slow average [ 21 ]: whole numbers from 2 to 200, defaults 9 and 21; fast must be smaller than slow
  • neutral band [ 0 ] %: a number from 0 to 10, default 0
• Gives back: UP when the fast average is above the slow one by more than the neutral band, DOWN when it is below by more than the band, otherwise NEUTRAL. NOT_READY when it cannot tell.
• How it works: It uses two exponential moving averages (averages that give more weight to the newest candles) of the closed candles, built the same way as Deriv's own EMA block. The band is a share of the slow average. It needs twice the slow period in closed candles; with fewer, or with a missing candle, it says NOT_READY and never a quiet NEUTRAL.
• Example:

┌─ 2. Purchase conditions ───────────────────────┐
│ if  < ( Bias on the [ 15 minutes ▾ ] candles   │
│         fast average [ 9 ] slow average [ 21 ] │
│         neutral band [ 0.05 ] % ) = [ UP ] >   │
│ then  Purchase [ Rise ▾ ]                      │
└────────────────────────────────────────────────┘

The bot buys only when the 9-candle average of the 15-minute candles is clearly above the 21-candle average.

• Good to know:
  • Refusals: a candle size not from the list; a fast or slow period that is not a whole number from 2 to 200; fast not smaller than slow; a band outside 0 to 10.
  • A moving-average bias lags the price. Test your strategy with and without it before trusting it.
  • It describes the past. It does not predict.

ATR

• Kind: BRINOVS custom, block #30 (Indicator pack, 1 of 4)
• Type id: bnv_atr
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted.
• What it does: Gives the average true range of the closed candles: the average size of a candle, counting gaps between candles too. It is in price units. It says nothing about direction.
• Inputs:
  • ATR (average true range) on the [ 1 minute ▾ ] candles: a size from 1 minute up to 1 day, default 1 minute
  • period [ 14 ]: a whole number from 2 to 200, default 14
• Gives back: a number in price units, or "not a number" when there are too few closed candles or a candle is missing.
• How it works: The "true range" of a candle is the biggest of its high minus low, and its distance from the previous close at the high and at the low. The first ATR is the plain average of the first period's true ranges, then it is smoothed (Wilder's method). It needs the period plus one closed candles.
• Example:

┌─ 2. Purchase conditions ───────────────────┐
│ if  < ( ATR (average true range) on the    │
│         [ 5 minutes ▾ ] candles            │
│         period [ 14 ] ) < [ 2.5 ] >        │
│ then  Purchase [ Rise ▾ ]                  │
└────────────────────────────────────────────┘

The bot buys only when the average 5-minute candle is smaller than 2.5 price units.

• Good to know:
  • Refusals: a candle size not from the list; a period that is not a whole number from 2 to 200.
  • It uses closed candles only. It describes candles that already closed and does not predict the next one.
  • The same measure is available as a choice inside the Volatility gate.

Rate of change

• Kind: BRINOVS custom, block #30 (Indicator pack, 2 of 4)
• Type id: bnv_roc
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted.
• What it does: Gives how much the closing price changed, in percent, compared with the close some candles ago.
• Inputs:
  • Rate of change on the [ 1 minute ▾ ] candles: a size from 1 minute up to 1 day, default 1 minute
  • period [ 10 ]: a whole number from 1 to 200, default 10
• Gives back: a percentage (it can be negative), or "not a number" when there are too few closed candles or a candle is missing.
• How it works: The formula is (latest close divided by the close one period ago, minus 1) times 100. It needs the period plus one closed candles.
• Example:

┌─ 2. Purchase conditions ─────────────────────────────┐
│ if  < ( Rate of change on the [ 1 minute ▾ ] candles │
│         period [ 10 ] ) > [ 0 ] >                    │
│ then  Purchase [ Rise ▾ ]                            │
└──────────────────────────────────────────────────────┘

The bot buys only when the close is higher than it was 10 candles ago.

• Good to know:
  • Refusals: a candle size not from the list; a period that is not a whole number from 1 to 200.
  • It describes the past. It does not predict the next candle.

Stochastic

• Kind: BRINOVS custom, block #30 (Indicator pack, 3 of 4)
• Type id: bnv_stochastic
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted.
• What it does: Gives the stochastic oscillator of the closed candles, from 0 to 100. It shows where the latest close sits inside the recent high-to-low range.
• Inputs:
  • Stochastic on the [ 1 minute ▾ ] candles [ %K ▾ ]: a size from 1 minute up to 1 day; %K (default) or %D
  • period [ 14 ]: a whole number from 2 to 200, default 14
  • smooth %K over [ 1 ] %D over [ 3 ]: smoothing of %K from 1 to 50, default 1 (1 means not smoothed); the %D period from 1 to 50, default 3
• Gives back: a number from 0 to 100, or "not a number" when there are too few closed candles, a candle is missing, or the highest high equals the lowest low.
• How it works: %K is 100 times (close minus lowest low) divided by (highest high minus lowest low) over the period, averaged over the smoothing. %D is the average of the last few %K values.
• Example:

┌─ 2. Purchase conditions ───────────────────────────────────┐
│ if  < ( Stochastic on the [ 5 minutes ▾ ] candles [ %K ▾ ] │
│         period [ 14 ]                                      │
│         smooth %K over [ 3 ] %D over [ 3 ] ) < [ 20 ] >    │
│ then  Purchase [ Rise ▾ ]                                  │
└────────────────────────────────────────────────────────────┘

The bot buys only when %K of the 5-minute candles is under 20, which means the close is near the bottom of its recent range.

• Good to know:
  • Refusals: a candle size not from the list; a period, smoothing or %D period outside its range; no choice of %K or %D.
  • Closed candles only. It describes the past and does not predict.

ADX

• Kind: BRINOVS custom, block #30 (Indicator pack, 4 of 4)
• Type id: bnv_adx
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted.
• What it does: Gives the average directional index (ADX), from 0 to 100. It shows how strong a trend has been, not which way it goes. +DI and -DI show the push up and the push down.
• Inputs:
  • ADX on the [ 1 minute ▾ ] candles [ ADX (trend strength) ▾ ]: a size from 1 minute up to 1 day; ADX (default), +DI or -DI
  • period [ 14 ]: a whole number from 2 to 100, default 14
• Gives back: a number from 0 to 100, or "not a number" when there are too few closed candles or a candle is missing.
• How it works: It uses Wilder's method on the closed candles. It needs twice the period in closed candles. A high ADX means a strong move in one direction or the other, and a low ADX means little trend.
• Example:

┌─ 2. Purchase conditions ────────────────────┐
│ if  < ( ADX on the [ 15 minutes ▾ ] candles │
│         [ ADX (trend strength) ▾ ]          │
│         period [ 14 ] ) > [ 25 ] >          │
│ then  Purchase [ Rise ▾ ]                   │
└─────────────────────────────────────────────┘

The bot buys only when the 15-minute candles have shown a strong trend (ADX above 25). It does not say which way the price will go next.

• Good to know:
  • Refusals: a candle size not from the list; a period that is not a whole number from 2 to 100; no choice of ADX, +DI or -DI.
  • It describes candles that already closed and does not predict.

Support / resistance zone

• Kind: BRINOVS custom, block #31
• Type id: bnv_sr_zone
• Shape: True/false block
• Where it goes: In an if inside "2. Purchase conditions".
• What it does: Says yes when the latest price is near a support or resistance zone found in the closed candles. Support is a price area where the price turned up before. Resistance is an area where it turned down before.
• Inputs:
  • Price is near a [ support ▾ ] zone on the [ 1 minute ▾ ] candles: support (default), resistance or support or resistance; candle size default 1 minute
  • look back [ 100 ] closed candles (30 to 500); swing width [ 3 ] candles each side (1 to 10)
  • zone width [ 0.5 ] x ATR (0.1 to 3); fewest touches [ 2 ] (2 to 10)
  • near means within [ 0.1 ] % of the price (0.01 to 5); work the zones out again every [ 5 ] new candles (1 to 100)
• Gives back: true when the price is near a zone of the kind you chose, false otherwise or when there is no answer.
• How it works: A swing high is a candle whose high is above the candles around it (a swing low is the mirror). Swing points that sit close together, within the zone width (a share of the ATR of 14), form a zone, and it counts only with enough touches. The newest candles cannot be swing points yet, so a zone always lags a little. The zones are worked out again only every few new candles, to keep the browser light.
• Example:

┌─ 2. Purchase conditions ─────────────────────────────────┐
│ if  < Price is near a [ support ▾ ] zone on the          │
│       [ 5 minutes ▾ ] candles                            │
│       look back [ 100 ] closed candles                   │
│       swing width [ 3 ] candles each side                │
│       zone width [ 0.5 ] x ATR                           │
│       fewest touches [ 2 ]                               │
│       near means within [ 0.1 ] % of the price           │
│       work the zones out again every [ 5 ] new candles > │
└──────────────────────────────────────────────────────────┘

The bot buys only when the price sits within 0.1 percent of a support zone.

• Good to know:
  • Refusals: a candle size not from the list; any of the numbers outside the ranges above; no kind of zone chosen. A zone is where the price turned before. It says nothing about the next turn, and the price can go straight through it.
  • The companion value block "Zone touches" (bnv_sr_zone_touches) has the same settings and gives the number of touches of the zone the price is near.

Zone touches

• Kind: BRINOVS custom, companion of block #31
• Type id: bnv_sr_zone_touches
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted. Use the same settings as your Support / resistance zone block.
• What it does: Tells you how many times the price turned at the zone it is near. The more touches, the more often the price turned there.
• Inputs: The same seven settings as the Support / resistance zone block, with the same defaults and ranges. Only the first line of the label differs: "Touches of the [ support ▾ ] zone the price is near, on the [ 1 minute ▾ ] candles".
• Gives back: a whole number of touches. 0 when the price is not near a zone. "Not a number" when there is no answer yet.
• How it works: It finds the zones like the Support / resistance zone block. If several zones are near, it uses the nearest one, and on a tie the one with more touches.
• Example:

┌─ 2. Purchase conditions ─────────────────────────────────────┐
│ if  < ( Touches of the [ support ▾ ] zone the price is near, │
│         on the [ 5 minutes ▾ ] candles                       │
│         look back [ 100 ] closed candles                     │
│         swing width [ 3 ] candles each side                  │
│         zone width [ 0.5 ] x ATR                             │
│         fewest touches [ 2 ]                                 │
│         near means within [ 0.1 ] % of the price             │
│         work the zones out again every [ 5 ] new candles )   │
│       ≥ [ 3 ] >                                              │
└──────────────────────────────────────────────────────────────┘

The bot buys only when the nearby support zone has been touched at least three times.

• Good to know:
  • It has the same refusals as the Support / resistance zone block.
  • Many touches do not mean the zone will hold. It describes the past only.

Candle pattern

• Kind: BRINOVS custom, block #32
• Type id: bnv_candle_pattern
• Shape: True/false block
• Where it goes: In an if inside "2. Purchase conditions".
• What it does: Says yes when the latest closed candle completes a named shape. A pattern is only a shape. Studies of whether these shapes predict anything are mixed, so a pattern does not make a win more likely.
• Inputs:
  • Latest closed candle is a [ bullish engulfing ▾ ]: bullish engulfing (default), bearish engulfing, hammer, shooting star, doji, inside bar, any bullish (engulfing, hammer), any bearish (engulfing, shooting star) or any of the six
  • on the [ 1 minute ▾ ] candles: default 1 minute
  • only after a fall (UP shapes) or a rise (DOWN shapes): [ yes ▾ ] (default) or [ no ▾ ]
• Gives back: true when the shape is completed by the latest closed candle.
• How it works: Engulfing: the body covers the body before it and is bigger. Hammer: the body is over 10 percent of the range, the lower shadow is at least 2 times the body, the upper shadow is at most 10 percent of the range. Shooting star: the mirror of a hammer. Doji: the body is at most 10 percent of the range. Inside bar: the high is lower and the low is higher than the candle before. With "only after a fall or rise" on, the UP shapes need the close before them to be lower than 3 candles earlier, and the DOWN shapes higher.
• Example:

┌─ 2. Purchase conditions ────────────────────────────────────┐
│ if  < Latest closed candle is a [ hammer ▾ ] on the         │
│       [ 5 minutes ▾ ] candles                               │
│       only after a fall (UP shapes) or a rise (DOWN shapes) │
│       [ yes ▾ ] >                                           │
│ then  Purchase [ Rise ▾ ]                                   │
└─────────────────────────────────────────────────────────────┘

The bot buys only when the last closed 5-minute candle is a hammer that came after a fall.

• Good to know:
  • Refusals: a candle size not from the list; no choice for "only after a fall or rise"; a pattern not from the list.
  • With "only after" on it needs 6 closed candles, otherwise 2. With too few candles, or a missing candle, it says no.
  • The companion value block "Candle pattern bias" (bnv_candle_pattern_bias) gives the word UP, DOWN, NEUTRAL, NONE or NOT_READY. The word is only the traditional name of the shape. It does not say the price will go that way.

Candle pattern bias

• Kind: BRINOVS custom, companion of block #32
• Type id: bnv_candle_pattern_bias
• Shape: Value block (gives a word)
• Where it goes: Anywhere a value is wanted.
• What it does: Gives the traditional name of the shape that the latest closed candle completes, as one word.
• Inputs:
  • Bias of the latest closed candle pattern on the [ 1 minute ▾ ] candles: default 1 minute
  • only after a fall (UP shapes) or a rise (DOWN shapes): [ yes ▾ ] (default) or [ no ▾ ]
• Gives back: UP (bullish engulfing, hammer), DOWN (bearish engulfing, shooting star) or NEUTRAL (doji, inside bar). If an UP and a DOWN shape both fit, NEUTRAL. NONE when no shape is completed. NOT_READY when there are too few candles or a candle is missing.
• How it works: It checks the six shapes of the Candle pattern block on the latest closed candle and turns the result into one word.
• Example:

┌─ 2. Purchase conditions ────────────────────────────────┐
│ if  < ( Bias of the latest closed candle pattern on the │
│         [ 5 minutes ▾ ] candles                         │
│         only after a fall (UP shapes) or a rise         │
│         (DOWN shapes) [ yes ▾ ] ) = [ UP ] >            │
│ then  Purchase [ Rise ▾ ]                               │
└─────────────────────────────────────────────────────────┘

The bot buys only when the last closed candle completes a shape that is traditionally read as UP.

• Good to know:
  • Refusals: a candle size not from the list; no choice for "only after a fall or rise".
  • UP and DOWN here are names of shapes. Mixed studies show they do not reliably say what comes next.

Confluence score

• Kind: BRINOVS custom, block #33
• Type id: bnv_confluence_score
• Shape: True/false block
• Where it goes: In an if inside "2. Purchase conditions". Its sockets take other true/false blocks.
• What it does: Says yes when at least N of the conditions you plug in are true. It is a plain "N of M" count, with no hidden weights and no score out of 100.
• Inputs:
  • At least [ 2 ] of these conditions are true: a whole number from 1 up to the number of sockets, default 2
  • condition 1, condition 2, condition 3: sockets for true/false blocks. A fresh block has 3.
  • the - and + buttons remove or add a socket (from 2 up to 10)
• Gives back: true when at least your number of conditions are true.
• How it works: The bot looks at every socket every time, from left to right. Only a value that is exactly true counts. An empty socket, false, "not a number" or text counts as not true. Every condition counts the same.
• Example:

┌─ 2. Purchase conditions ─────────────────────────────────────┐
│ if  < At least [ 2 ] of these conditions are true            │
│       condition 1 < Last [ 3 ] ticks are [ rising ticks ▾ ]> │
│       condition 2 < Confirmed [ 3 ] times in a row ... >     │
│       condition 3 < Volatility is normal ... >   [-] [+] >   │
│ then  Purchase [ Rise ▾ ]                                    │
└──────────────────────────────────────────────────────────────┘

The bot buys when at least two of the three conditions are true at the same moment. (The plugged-in blocks are shortened here.)

• Good to know:
  • Refusals: fewer than 2 or more than 10 conditions; a number needed that is not a whole number from 1 to the number of sockets.
  • Agreement does not make a win more likely. Many conditions are made from the same prices.
  • The companion value block "Confluence count" (bnv_confluence_count) gives the number of true conditions (0 up to the number of sockets) instead of a yes or no.

Confluence count

• Kind: BRINOVS custom, companion of block #33
• Type id: bnv_confluence_count
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted. Its sockets take true/false blocks.
• What it does: Counts how many of the conditions you plug in are true right now. Use it in a comparison when you want more than a yes or no.
• Inputs:
  • condition 1, condition 2, condition 3: sockets for true/false blocks. A fresh block has 3.
  • the - and + buttons remove or add a socket (from 2 up to 10)
• Gives back: a whole number from 0 up to the number of sockets.
• How it works: It works like Confluence score, but returns the count. Only an exactly true value counts, every socket is looked at every time, and an empty socket counts as not true.
• Example:

┌─ 2. Purchase conditions ───────────────────────────────────┐
│ if  < ( How many of these conditions are true              │
│    condition 1 < Cooldown over ... >                       │
│    condition 2 < Volatility is normal ... >                │
│    condition 3 < Last [ 3 ] ticks are [ falling ticks ▾ ]> │
│    [-] [+] ) = [ 3 ] >                                     │
│ then  Purchase [ Under ▾ ]                                 │
└────────────────────────────────────────────────────────────┘

The bot buys only when all three conditions are true. (The plugged-in blocks are shortened here.)

• Good to know:
  • Refusals: fewer than 2 or more than 10 conditions.
  • It only counts. It does not say that more agreement means a better chance to win.