{"id":459,"date":"2026-05-22T15:28:10","date_gmt":"2026-05-22T13:28:10","guid":{"rendered":"https:\/\/actilud.com\/info\/en\/?p=459"},"modified":"2026-05-27T18:18:04","modified_gmt":"2026-05-27T16:18:04","slug":"the-formula-instruction","status":"publish","type":"post","link":"https:\/\/actilud.com\/info\/en\/the-formula-instruction\/","title":{"rendered":"The FORMULA instruction"},"content":{"rendered":"
\n

Coming soon to Actilud. Article under construction.<\/span><\/strong>\u00a0Applies a mathematical formula. The formula can be applied to all calculable values.<\/span><\/span><\/p>\n

f(a,b,c) = a * (cb)<\/span><\/p><\/blockquote>\n

Since the May 2026 update, the SUM, TOTAL, THRESHOLD instructions use the FORMULA instruction.<\/span><\/p>\n

This instruction was programmed to allow the creation of original puzzles, such as the <\/span>stock market<\/span><\/em>\u00a0game on Actilud. In this game, Alice sells 5 shares that she had previously bought. For each share, we know the name, the selling price, the unit purchase price, and the quantity sold. This allows us to create statements of the type:<\/span><\/p>\n

\n
    \n
  1. Styledsteel’s share price rose by \u20ac10: purchase price \u2013 selling price<\/span><\/li>\n
  2. The sale of Foolishbuild shares generated a capital gain of \u20ac100: quantity * (purchase price \u2013 sale price)<\/span><\/li>\n<\/ol>\n<\/blockquote>\n

    In a formula, each computable value must be represented algebraically, by a letter. The first letter used must always be a\u00a0<\/span>,\u00a0<\/span><\/em>\u00a0and subsequent letters, if any, must appear in alphabetical order. In our game, we have three computable values:\u00a0\u00a0<\/span>a, b, c<\/span><\/em>\u00a0.<\/span><\/p>\n

    To obtain our statement of type (1), we set:<\/span><\/p>\n

      \n
    • a is the unit purchase price<\/span><\/li>\n
    • b is the unit selling price.<\/span><\/li>\n<\/ul>\n

      The formula is therefore: f(a,b) = ba<\/span><\/p>\n

      selling price \u2013 purchase price<\/span><\/p><\/blockquote>\n

      We can see that this formula can generate a positive number (a capital gain), a negative number (a loss), or a zero result, if the stock was sold at its purchase price.<\/span><\/p>\n

      We can also decide that\u00a0<\/span>a<\/span><\/em>\u00a0is the selling price and\u00a0<\/span>b<\/span><\/em> the buying price! In this case, the formula will be reversed: f(a,b)=a-b. The choice of values \u200b\u200bfor a and b is programmable.<\/span><\/p>\n

      To obtain a statement of type (2), we set:<\/span><\/p>\n

        \n
      • a is the unit purchase price<\/span><\/li>\n
      • b is the unit selling price.<\/span><\/li>\n
      • That’s the quantity sold.<\/span><\/li>\n<\/ul>\n

        The formula is therefore: f(a,b,c) = c*(b-a)<\/span><\/p>\n

        quantity * (selling price \u2013 purchase price)<\/span><\/p><\/blockquote>\n

        This gives us the amount of the capital gain, or loss, realized by Alice on a given share (here: Foolishbuild) at the time of the sale.<\/span><\/p>\n

        Note the operators: the “multiply” sign is not an “x” as usual, but the “*” sign. This is computer coding (to avoid confusion between the multiplication sign and the letter x).<\/span><\/p>\n

        The operators<\/span><\/h3>\n
          \n
        • The standard operators are: + (addition), \u2013 (subtraction), * (multiplication), \/ (division), % (modulo)<\/span><\/li>\n
        • parentheses<\/span><\/li>\n
        • The comparison operators are: < (less), <= (less or equal), == (equal), != (not equa), > (greater), and >= (greater or equal). These operators return a Boolean value (true or false). Upon exiting the formula, the Boolean values \u200b\u200bare converted to numbers ( <\/span>false<\/span><\/em>\u00a0is translated to 0 and\u00a0<\/span>true<\/span><\/em>\u00a0to 1).<\/span><\/li>\n
        • The unary operator ! (not):\u00a0<\/span>!a<\/span><\/em>\u00a0is true if\u00a0<\/span>a<\/span><\/em>\u00a0is false, false if\u00a0<\/span>a<\/span><\/em>\u00a0is true.\u00a0<\/span>!(a<b)<\/span><\/em>\u00a0is true if\u00a0<\/span>a >= b<\/span><\/em><\/li>\n
        • The ternary operator:\u00a0<\/span>expression? value_if_true<\/span><\/em>\u00a0\u00a0:\u00a0<\/span>value if false \u2013<\/span><\/em> for example: (a-b)>=0?1:0 returns 1 if (a-b) >=0, 0 otherwise<\/span><\/li>\n
        • all the formulas available in the Javascript Math library, including:<\/span>\n
            \n
          • Math.sign(expression): returns -1 if the expression is negative, 0 if it is zero, 1 if it is positive<\/span><\/li>\n
          • Math.floor(expression): returns the integer part<\/span><\/li>\n
          • Math.round(expression): rounds the expression to the nearest whole number<\/span><\/li>\n
          • Math.abs(expression) returns the absolute value of the expression<\/span><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n

            Any operation that can be performed in Javascript, and that fits in a single line, can be programmed.<\/span><\/p>\n

            Since the introduction of FORMULA, SUM is coded as f(a,b) = a + b and TOTAL, in the game “The Orchard”, is coded as f(a,b,c) = a + b + c. The SUM and TOTAL instructions are retained for compatibility reasons, and also because they are easier to program than FORMULA! Note, however, that FORMULA does not need to define “summable” series, as all computable series are available.<\/span><\/p>\n

            Attention !<\/span><\/h4>\n

            All calculations are performed on real numbers. Therefore, rounding approximations may occur in complex formulas. In such cases, use Math.round.<\/span><\/p>\n

            The parameters<\/span><\/h1>\n

            Formula name<\/span><\/h3>\n

            This is the name that will be displayed in the formal proposal. For example, for point (2), you can call your formula “GAINVALUE” (only letters and numbers are allowed). For point (1), you can call the formula “VARIATION” which reflects the change in the unit price between the sale and the purchase.<\/span><\/p>\n

            The summarizing statement will be, for example:<\/span><\/p>\n

            Foolishbuild: GAINVALUE(unit purchase price, unit selling price, quantity) = 500<\/span><\/p>\n

            Styledsteel: VARIATION (unit purchase price, unit selling price) = -20<\/span><\/p><\/blockquote>\n

            Reference series<\/span><\/h3>\n

            Reminder: A\u00a0<\/span>series<\/span><\/strong>\u00a0is formed by a header and values. By default, the series name is the same as the header name. Example: The\u00a0<\/span>purchase price\u00a0<\/span><\/em>\u00a0series is formed by the header\u00a0\u00a0<\/span>purchase price<\/span><\/em>\u00a0and the values \u200b\u200b{10, 20, 30, 40, 50}.<\/span><\/p>\n

            The\u00a0<\/span>reference<\/span><\/strong>\u00a0series is the series to which the formula is applied. In our example, it’s the\u00a0<\/span>name series,<\/span><\/em>\u00a0which contains\u00a0<\/span>Styledsteel<\/span><\/em>\u00a0or\u00a0Foolishbuild<\/em><\/span>\u00a0. You can choose a specific series or let the algorithm choose randomly.<\/span><\/p>\n

            The random selection is made from the series not included in the formula at the time of its execution. In case (1), the variable\u00a0<\/span>a\u00a0<\/span><\/em>\u00a0is always the purchase price and\u00a0\u00a0<\/span>b\u00a0<\/span><\/em> is always the selling price. The reference series can therefore be chosen between “stock name<\/em><\/span>“<\/span><\/em>\u00a0or\u00a0<\/span>“quantity”<\/span><\/em>\u00a0. The choice will be made randomly from the two possibilities. If the choice is made from the quantity, a statement of the type will be produced:<\/span><\/p>\n

            30: VARIATION (unit purchase price, unit selling price) = -20<\/span><\/p>\n

            The lot of 30 lost \u20ac20 per share.<\/span><\/p><\/blockquote>\n

            Series a, b, c, \u2026<\/span><\/h3>\n

            This is where we indicate the series in which the variables\u00a0<\/span>a, b, c,\u2026\u00a0<\/span><\/em>\u00a0will find their values.<\/span><\/p>\n

            This is a table of checkboxes. Each column corresponds to a variable in the formula: a, b, c, \u2026 Each row is a computable series in our puzzle (so in our case, the stock names are not included). The columns must be filled in from left to right. It is forbidden to leave a column empty between two filled columns. Therefore, we must start with <\/span>a,\u00a0<\/span><\/em>\u00a0then\u00a0\u00a0<\/span>b,\u00a0<\/span><\/em>\u00a0and so on.<\/span><\/p>\n

            In our example, case (1), formula\u00a0<\/span>\u00a0 f(a,b) = b-a,<\/span><\/em>\u00a0we will check the boxes\u00a0<\/span>(a,\u00a0<\/span><\/em>\u00a0unit purchase price), (\u00a0<\/span><\/em>b,\u00a0<\/span><\/em>unit selling price)\u00a0<\/span><\/em>.<\/span><\/em>\u00a0For case (2), formula\u00a0<\/span>f(a,b,c)=c*(b-a)<\/span><\/em>\u00a0, we will check\u00a0<\/span>(a, unit purchase price)<\/span><\/em>\u00a0,\u00a0<\/span>(b, unit selling price)<\/span><\/em>\u00a0,\u00a0<\/span>(c, quantity)\u00a0<\/span><\/em>\u00a0.<\/span><\/em><\/p>\n

            \"\"
            Case 2: Assignment of a, b, c to the series<\/span><\/figcaption><\/figure>\n

            Select multiple series for the same variable<\/span><\/h4>\n

            If a variable is associated with multiple series, the algorithm processes each selected series, provided the series is not already chosen by the preceding variables. To illustrate this, let’s consider the <\/span>orchard<\/span><\/em>\u00a0puzzle where we have three computable series concerning the weight of\u00a0<\/span>walnuts,<\/span><\/em>\u00a0apples<\/em>\u00a0<\/span>,<\/span><\/em>\u00a0and\u00a0<\/span>pears<\/span><\/em>\u00a0. We want to sum two series at random. We will choose\u00a0<\/span>the three series<\/span><\/strong>\u00a0for `a` and `b`. The calculations will be performed on `(walnuts, apples), (walnuts, pears), (apples, pears)`, with `a` and `b` always chosen from different series. Since the formula is commutative, there are only 3 possible combinations. Here, the variable\u00a0\u00a0<\/span>`c`\u00a0<\/span><\/em>\u00a0is not used in the formula: therefore, we leave column `c` empty\u00a0<\/span>.<\/span><\/em><\/p>\n

            \"\"
            a and b will be chosen randomly from among walnuts, apples, and pears.<\/span><\/figcaption><\/figure>\n

            Unused variable in the formula<\/span><\/h4>\n

            Empty columns are always located on the last variables. The variables associated with empty columns are not used in the formula.<\/span><\/p>\n

            f(a,\u2026)=<\/span><\/h3>\n

            Formula in algebraic form using the variables a, b, c. Your formula will be compiled in real time and tested on\u00a0<\/span>all possible combinations<\/span><\/em>\u00a0generated by your series. Therefore, carefully check the syntax and pay attention to potential problems, such as division by zero!<\/span><\/p>\n

            The formula is commutative.<\/span><\/h3>\n

            Check the box if the formula is commutative. This is the case for instructions of the type SUM: a+b. Indeed, a+b = b+a. This speeds up calculations by avoiding unnecessary combinations. In the case of the\u00a0<\/span>orchard<\/span><\/em>\u00a0puzzle , commutativity will only produce sums of the type (walnuts, apples), (walnuts, pears), (apples, pears). Other possible combinations, such as (pears, apples), will be ignored because they are already handled by the commutative equivalent.<\/span><\/p>\n

            Working with constants<\/span><\/h2>\n

            In the general case, the constant is written directly into the formula:<\/span><\/p>\n

            a < 30<\/span>
            \nreturns 1 for all values \u200b\u200bof a less than 30, and 0 for all those greater than or equal to 30.<\/span><\/p><\/blockquote>\n

            These values \u200b\u200bcan then be filtered (see below), to retain, for example, only the values \u200b\u200bof 1.<\/span><\/p>\n

            We may wish to choose the constant from the values \u200b\u200bin a series, without knowing that value precisely. In this case, we use the\u00a0<\/span>constant K,\u00a0<\/span><\/strong>\u00a0which must be associated with one of the variables already defined.<\/span><\/p>\n

            a < K<\/span>
            \nreturns 1 for all values \u200b\u200bof a less than K, K being chosen from the values \u200b\u200bof a.<\/span><\/p><\/blockquote>\n

            To use the constant K in the formula, check one of the boxes located under the variables.<\/span><\/p>\n

            Note: K is not\u00a0\u00a0<\/span>actually<\/span><\/em>\u00a0<\/span> a constant, even though that’s how you should treat it when writing the formula. In reality, all possible values<\/em> of K will be handled in your formula, just like variables.<\/p>\n

            The filters<\/span><\/h2>\n

            There are three filters that allow you to accept or reject a formula, depending on its result, the number of combinations it creates, or the impact it has on the game grid.<\/span><\/p>\n

            Accepted results, excluded results:<\/span><\/h3>\n

            You can request that your formula return a result chosen from a set. Enter all desired results, separated by commas, in the\u00a0<\/span>accepted field.<\/span><\/em><\/p>\n

            Some results are undesirable. You can exclude them in the corresponding field. In the\u00a0\u00a0<\/span>stock market puzzle,<\/span><\/em> the value 0 is excluded for formulas because we want to avoid statements that contain gains of 0.<\/span><\/p>\n

            Numbers are in standard computer format: a continuous sequence of digits. If the number is a decimal (with a comma), use\u00a0<\/span>the decimal point<\/span><\/strong>\u00a0on the numeric keypad.<\/span><\/p>\n

            By default, leave the fields empty.<\/span><\/p>\n

            Combinatorial threshold<\/span><\/h3>\n

            Several values \u200b\u200bfor a, b, c\u2026 can produce the same result. For example, our function VARIATION=b-a can give a result of 10. This result is possible for several values \u200b\u200bof (a,b): (10,20); (20,30); (30,40); (40,50), giving 4 possible pairs. We say that the size of the combination is 4. A result of 40, however, is only possible for one pair: (10,50). The size of the combination here is 1.<\/span><\/p>\n

            The combinatorial threshold defines the acceptable size of the combination generated by the formula.<\/span><\/p>\n

            Threshold >= 0:<\/span><\/strong>\u00a0the size of the combination must be\u00a0<\/span>strictly greater<\/span><\/strong>\u00a0than the threshold. The value 0 is the default: all results are accepted, regardless of the size of the combination \u2013 a result requires at least one pair. A value of 1 makes the game more difficult: indeed, only one pair for a given result allows the player to find the values \u200b\u200band mark\u00a0<\/span>true\u00a0<\/span><\/em>\u00a0signs in the grid, because there is only one solution. See the result 40. The higher the threshold, the more difficult the game. But be careful not to set it too high, or the formula will become ineffective!<\/span><\/p>\n

            Threshold <0:<\/span><\/strong>\u00a0the number of combinations must be\u00a0<\/span>exactly<\/span><\/strong>\u00a0as specified, in absolute value: in our example, a combination of -1 will only allow the values \u200b\u200b(10, 50), with a result of 40. This can be useful for creating easy puzzles. You must ensure that the threshold does not contradict the list of accepted or excluded results.<\/span><\/p>\n

            Moves limit<\/span><\/h3>\n

            During the formula evaluation, all cases are processed in a random order. This random order means that the items are not processed in the order they appear in their series. Each accepted result is recorded: this is a possible “move.” Once all possible moves have been generated, or a maximum of 150 moves has been reached, the software selects a single move from the list, the one with the highest evaluation score.<\/span><\/p>\n

            If you consider all possible cases, then, inevitably, the evaluation will only retain the moves it prefers\u2026 and will often produce the same statements. Thus, in \u201cstandard\u201d mode, the software prioritizes \u201ctrue\u201d over \u201cfalse\u201d and Boolean values. It will therefore only retain the most trivial solutions, those that always produce \u201ctrue\u201d in the grid. For example, if you perform a comparison of the type a<K, and if\u00a0<\/span>a<\/span><\/em>\u00a0is a number between {10, 20, 30, 40, 50}, the software will retain the formulas that satisfy a<20, because they create a \u201ctrue\u201d in the cell associated with \u201c10\u201d, which earns more points in the evaluation.<\/span><\/p>\n

            To counter this effect, the number of generated moves can be limited. This limit can be drastic. For example, to simulate the THRESHOLD instruction, the formula a<K or a>K is indeed used, but the number of moves is limited to 1. This creates more variability in the statements. Furthermore, the calculations are considerably accelerated since formula evaluation stops as soon as a move is found. This isn’t necessarily the best possible move, but at least trivial statements are avoided.<\/span><\/p>\n

            Grid coding<\/span><\/h3>\n

            This occurs after the previous filters have been applied. The formula is effectively applied to the grid. This can produce boolean values, false values, or even, if there is only one pair,\u00a0\u00a0<\/span>true values.\u00a0<\/span><\/em>\u00a0Note that the effects on the grid depend on its state at the time the instruction is executed. If other instructions have been executed beforehand, they may affect the grid’s population.<\/span><\/p>\n

            Immediate<\/span><\/em>\u00a0coding\u00a0 should produce a change in the grid.\u00a0<\/span>Delayed\u00a0<\/span><\/em>\u00a0coding\u00a0should produce no change in the grid. This makes the formulas more difficult.<\/span><\/p>\n

            The coding was implemented to maintain compatibility with the TOTAL instruction. Note, however, the imprecision of this directive. The order in which the statements are created does not necessarily correspond to the order the player will use. For a player, a statement may very well cause a change in the grid, even though it did not produce any change for the program at creation’s time.<\/span><\/p>\n

            \"\"<\/p>\n

            Isolated: if the instruction is running in isolated mode, the designer does not choose rows that already contain signs, including booleans.<\/span><\/p>\n

            \"\"<\/p>\n

            Maximum: the maximum number of times this instruction can be executed.<\/span><\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

            Coming soon to Actilud. Article under construction.\u00a0Applies a mathematical formula. The formula can be applied to all calculable values. f(a,b,c) = a * (cb) Since the May 2026 update, the SUM, TOTAL, THRESHOLD instructions use the FORMULA instruction. This instruction was programmed to allow the creation of original puzzles, such as the stock market\u00a0game on […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[],"class_list":["post-459","post","type-post","status-publish","format-standard","hentry","category-zebra-puzzles-glossary-of-programming-instructions"],"_links":{"self":[{"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/posts\/459","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/comments?post=459"}],"version-history":[{"count":12,"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/posts\/459\/revisions"}],"predecessor-version":[{"id":471,"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/posts\/459\/revisions\/471"}],"wp:attachment":[{"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/media?parent=459"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/categories?post=459"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/actilud.com\/info\/en\/wp-json\/wp\/v2\/tags?post=459"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}