44:["$","title",null,{"children":"Mindshift: Part 18 | Chris Whealy | Observable"}] 4c:T404,md`# Mindshift: Part 18 Republished on Dec 7th, 2018 # Subtraction Using Addition Now that we can work out the SUCCessor and PREDecessor of our special signed functions, we are now in a position to look at performing simple arithmetic functions such as ADD and SUBTRACT. ## How Does Addition Currently Work? Previously, when we used a "naked" abstract quantity function to represent an unsigned integer, addition and subtraction were easy - as long as the result was a positive integer. If we take another look at the calculations used for unsigned integers, then the addition of two quantity functions a and b was simply a matter of finding the b'th SUCCessor of a. Similarly, as long as the answer was greater than or equal to 0, subtracting b from a required us to find the b'th PREDecessor of a. Here's how we previously did addition:`4d:Tb39,md`Well, that's easy enough... ## The Sign Points The Way! However, now we are no longer dealing with "naked" quantity functions. Instead, we are dealing with a PAIR formed from a Boolean sign and an abstract quantity function (the magnitude). Therefore, when we start adding and subtracting these PAIRs, we must take into account the sign of the number and then add or subtract as necessary. The limitation with our previous ADD and SUBTRACT functions is that they cannot perform any calculation that requires passing through 0 - and this limitation isn't going to go away simply because we've added a sign to the front of an integer. However, this will not stop us being able to perform all the needed calculations. So when we subtract 5 from 5, we expect to get an answer of -2; however, if we attempted this calculation using the current definition of SUBTRACT, all we would get is 0. However, we can also obtain the correct answer by recognising that since 5 is greater than 3, we invert the subtraction to give 5 - 3 = +2 and flip the sign of the result to give the required -2. So addition and subtraction now become slightly more complicated in that we first need to test whether the two numbers have same sign, and secondly, if the signs are different, we must subtract the smaller operand from the larger. Let's write out how the different combinations of signs should be handled. The table below shows how substraction operations should be handled based on the sign and magnitude of the operands. | Operand 1 | Operand 2 | Returns |:-:|:-:|:-: | +n1 | +n2 | +(n1+n2) | -n1 | -n2 | -(n1+n2) | +n1 | -n2 | if n2 <= n1 then +(n1-n2) else -(n2-n1) | -n1 | +n2 | if n1 <= n2 then +(n2-n1) else -(n1-n2)
One striking thing to notice about this table is that even though it describes the behaviour of the operation we are calling ADD, we are actually more likely to subtract the two operands than add them. If fact, the only time we perform an addition is when both operands have the same sign. The rest of the time we're subtracting! ## We Can Reuse Our Existing ADD and SUBTRACT functions Since we still need to add and subtract abstract quantity functions, the functionality contained within our existing ADD and SUBTRACT functions is still going to be needed; however, we must rename these functions to better describe what they do. So ADD becomes ADD_MAGNITUDES and SUBTRACT becomes SUBTRACT_MAGNITUDES.`4e:T682,ADD = num1 => num2 => // Inner function (qtyFn1 => qtyFn2 => // Is the 1st number +ve? lib.IS_POS(num1) // Yup, what's the sign of the 2nd number? (lib.IS_POS(num2) // Both numbers are +ve // Return sum of magnitudes and +ve sign (lib.NUMBER(lib.TRUE)(ADD_MAGNITUDES(qtyFn1)(qtyFn2))) // 2nd number is -ve // Which number is bigger? (IS_LTE(num1)(num2) // 1st number is bigger // Subtract 2nd number from 1st and return with +ve sign (lib.NUMBER(lib.TRUE)(SUBTRACT_MAGNITUDES(qtyFn1)(qtyFn2))) // 2nd number is bigger // Subtract 1st number from 2nd and return with -ve sign (lib.NUMBER(lib.FALSE)(SUBTRACT_MAGNITUDES(qtyFn2)(qtyFn1))))) // Nope, so is the 2nd number +ve? (lib.IS_POS(num2) // 2nd number is +ve // Which number is bigger? (IS_LTE(num1)(num2) // 2nd number is bigger // Subtract 1st number from 2nd and return with +ve sign (lib.NUMBER(lib.TRUE)(SUBTRACT_MAGNITUDES(qtyFn2)(qtyFn1))) // 1st number is bigger // Subtract 2nd number from 1st and return with -ve sign (lib.NUMBER(lib.FALSE)(SUBTRACT_MAGNITUDES(qtyFn1)(qtyFn2)))) // Both numbers are -ve // Return sum of magnitudes with -ve sign (lib.NUMBER(lib.FALSE)(ADD_MAGNITUDES(qtyFn1)(qtyFn2)))) ) // Extract the numbers' absolute values and pass them to the above inner function (lib.ABS(num1)) (lib.ABS(num2))4f:T4552,lib = { // ******************************************************************** // Naming Conventions // // Functions with all uppercase names return abstract functions // // Functions with all lowercase names return native JavaScript data // types // ******************************************************************** // ******************************************************************** // Generic operations // ******************************************************************** var adder = val1 => val2 => val1 + val2; var multiplier = p => q => q*p; var str_concatenate = char => acc => acc.concat(char); var asPlusChar = str_concatenate('+'); // The increment and decrement functions can now be created var incr = adder(1); var decr = adder(-1); // Use the multiplier function to create partial functions that // double, triple and quadruple their subsequent operand var double = multiplier(2); // -> double = q => q*p (p = 2) var triple = multiplier(3); // -> triple = q => q*p (p = 3) var quadruple = multiplier(4); // -> quadruple = q => q*p (p = 4) var add5 = adder(5); // -> add5 = q => q+5 // ******************************************************************** // Function Composition // ******************************************************************** var compose = fn1 => fn2 => val => fn2(fn1(val)); // Now we can "compose" double and add5 into a single function var doubleAndAdd5 = compose(double)(add5); // ******************************************************************** // Reification functions // ******************************************************************** var to_string = qtyFn => qtyFn(asPlusChar)('') var to_boolean = fn => fn(true)(false) // ******************************************************************** // Functions that operate on pairs and return abstract functions // ******************************************************************** var TRUE = true_part => false_part => true_part var FALSE = true_part => false_part => false_part // HEAD and TAIL are synonyms for TRUE and FALSE var HEAD = pair => pair(TRUE) var TAIL = pair => pair(FALSE) var PAIR = val1 => val2 => fn => fn(val1)(val2) var EMPTY_LIST = PAIR(null)(null) var IS_EMPTY = pair => (HEAD(pair) === null && TAIL(pair) === null) ? TRUE : FALSE var IS_LAST = pair => IS_EMPTY(TAIL(pair)) // ******************************************************************** // Functions that operate on pairs and return JavaScript data types // ******************************************************************** var is_empty = pair => (HEAD(pair) === null) && (TAIL(pair) === null) var is_last = pair => is_empty(TAIL(pair)) var is_pos = number => to_boolean(IS_POS(number)) // ******************************************************************** // Boolean Operators // ******************************************************************** var NOT = bool => bool(FALSE)(TRUE); var AND = bool1 => bool2 => bool1(bool2)(FALSE); var OR = bool1 => bool2 => bool1(TRUE)(bool2); var XOR = bool1 => bool2 => bool1(NOT(bool2))(bool2); // ******************************************************************** // Define an abstract quantity function for unsigned ZERO and ONE // ******************************************************************** var ZERO_MAGNITUDE = transform => start_value => start_value var UNIT_MAGNITUDE = transform => start_value => transform(start_value) // ******************************************************************** // Signed integer functions // ******************************************************************** var NUMBER = isPositive => qtyFn => PAIR(isPositive)(qtyFn) var ABS = number => TAIL(number) var SIGN = number => HEAD(number) var ZERO = NUMBER(TRUE)(ZERO_MAGNITUDE) // ******************************************************************** // Predicate functions // ******************************************************************** var IS_POS = SIGN var IS_ZERO = number => ABS(number)(dont_care => FALSE)(TRUE) var HAS_ZERO_MAGNITUDE = number => ABS(number)(dont_care => FALSE)(TRUE) var HAS_UNIT_MAGNITUDE = number => magnitude(ABS(number)) === 1 ? TRUE : FALSE var IS_LTE = val1 => val2 => IS_ZERO(SUBTRACT(val1)(val2)); var IS_LT = val1 => val2 => NOT(IS_LTE(val2)(val1)); var IS_MINUS_ONE = number => AND(NOT(IS_POS(number))) (HAS_UNIT_MAGNITUDE(number)) // ******************************************************************** // Reify signed integers // ******************************************************************** var magnitude = qtyFn => qtyFn(incr)(0) // ******************************************************************** // Successor and predecessor functions // ******************************************************************** var SUCC_MAGNITUDE = qtyFn => transform => start_value => transform(qtyFn(transform)(start_value)) var SUCC_MAGNITUDE_PAIR = pair => PAIR(pair(FALSE))(SUCC_MAGNITUDE(pair(FALSE))) var PRED_MAGNITUDE = qtyFn => qtyFn(SUCC_MAGNITUDE_PAIR) (PAIR(ZERO_MAGNITUDE) (ZERO_MAGNITUDE)) (TRUE) var SUCC = number => // Is the number positive? IS_POS(number) // Yup, so it must be >= 0, therefore return the positive // number created by calling SUCC_MAGNITUDE on the number's // absolute value (NUMBER(TRUE)(SUCC_MAGNITUDE(ABS(number)))) // Nope, so check for the special case of minus one (IS_MINUS_ONE(number) // Yup, so return value of ZERO (ZERO) // Nope, so the number must be <= -2 // Therefore, return the negative number // created by calling PRED_MAGNITUDE on the // number's absolute value (NUMBER(FALSE)(PRED_MAGNITUDE(ABS(number))))) var PRED = number => // Check for the special case of zero (IS_ZERO(number) // Yup, so return MINUS_ONE (NUMBER(FALSE)(UNIT_MAGNITUDE)) // Is the number positive? (IS_POS(number) // Yup, so the number must be >= 1 // Return the positive number created by calling // PRED_MAGNITUDE on the number's absolute value (NUMBER(TRUE)(PRED_MAGNITUDE(ABS(number)))) // Nope, so the number must be <= -1 // Therefore, return the negative number // created by calling SUCC_MAGNITUDE on the // number's absolute value (NUMBER(FALSE)(SUCC_MAGNITUDE(ABS(number)))))) // ******************************************************************** // Signed integers // ******************************************************************** var PLUS_ONE = SUCC(ZERO) var PLUS_TWO = SUCC(PLUS_ONE) var PLUS_THREE = SUCC(PLUS_TWO) var PLUS_FOUR = SUCC(PLUS_THREE) var PLUS_FIVE = SUCC(PLUS_FOUR) var MINUS_ONE = PRED(ZERO) var MINUS_TWO = PRED(MINUS_ONE) var MINUS_THREE = PRED(MINUS_TWO) var MINUS_FOUR = PRED(MINUS_THREE) var MINUS_FIVE = PRED(MINUS_FOUR) // ******************************************************************** // Arithmetic operations based on abstract quantity functions // ******************************************************************** var ADD = qtyFn1 => qtyFn2 => qtyFn1(SUCC)(qtyFn2); var MULTIPLY = qtyFn1 => qtyFn2 => qtyFn1(ADD(qtyFn2))(ZERO_MAGNITUDE); var POWER = qtyFn1 => qtyFn2 => qtyFn2(MULTIPLY(qtyFn1))(UNIT_MAGNITUDE); var SUBTRACT = qtyFn1 => qtyFn2 => qtyFn2(PRED)(qtyFn1); // ******************************************************************** // Combinators // ******************************************************************** var U = fn => fn(fn); var Y = (rec_fn => (gen_rec => U(gen_rec)) (gen_rec => rec_fn((n,a,b) => U(gen_rec)(n,a,b))) ) // ******************************************************************** // Create our own push function that returns the new array rather than // the index of the newly inserted item // ******************************************************************** var push = arr => val => (idx => arr)(arr.push(val)); // ******************************************************************** // Convert a character string to a list whilst preserving the // character order // ******************************************************************** var make_str2list = fn_next=> list => str => (str.length > 0) ? fn_next(PAIR(str.substr(-1))(list))(str.slice(0,-1)) : list; var str2list = str => Y(make_str2list)(EMPTY_LIST)(str); // ******************************************************************** // Convert a list back into a character string // ******************************************************************** var make_list2str = fn_next=> str => list => is_last(list) ? str.concat(HEAD(list)) : fn_next(str.concat(HEAD(list)))(TAIL(list)); var list2str = list => Y(make_list2str)("")(list); // ******************************************************************** // Convert a JavaScript array into a list // ******************************************************************** var make_array2list = fn_next=> list => array => (array.length === 0) ? list : fn_next(PAIR(array[array.length-1])(list)) (array.slice(0,-1)); var array2list = Y(make_array2list)(EMPTY_LIST); // ******************************************************************** // Convert a list to a JavaScript array // ******************************************************************** var make_list2array = fn_next=> arr => list => is_last(list) ? push(arr)(HEAD(list)) : fn_next(push(arr)(HEAD(list)))(TAIL(list)); var list2array = list => Y(make_list2array)([])(list); // ******************************************************************** // Reverse a list // ******************************************************************** var do_reverse = next_rev => new_list => old_list => IS_LAST(old_list) (PAIR(HEAD(old_list))(new_list)) (f => (next_rev(PAIR(HEAD(old_list))(new_list)) (TAIL(old_list))) (f)) var REVERSE = Y(do_reverse)(EMPTY_LIST) // ******************************************************************** // Generic MAP function // ******************************************************************** var make_map = next_map => new_list => fn => list => (list_acc => // Have we reached the end of the list? IS_LAST(list) // Yup, so reverse the items in the list and // we're done (f => REVERSE(list_acc)(f)) // Nope, so recursively call ourselves passing // in the list accumulator, the function being // applied and whatever is left in the current // list (f => (next_map(list_acc) (fn) (TAIL(list))) (f)) ) // Apply the mapping function to the first list item and // append the result to the start of the new list. This // value is then received as argument list_acc in the // function above (PAIR(fn(HEAD(list)))(new_list)) var MAP = Y(make_map)(EMPTY_LIST) // ******************************************************************** // Generic REDUCE function // ******************************************************************** var make_reduc = next_reduc => list => fn => acc => (new_acc => // Have we reached the end of the list? IS_LAST(list) // Yup, so simply return the accumulator (f => (new_acc)(f)) // Nope, so recursively call ourselves passing the // remainder of the list, the reduction function and the // new accumulator value (f => (next_reduc(TAIL(list)) (fn) (new_acc)) (f) ) ) // Calculate the new accumulator value. This value // appears as parameter new_acc in the above function (fn(HEAD(list))(acc)) // Create the REDUCE function using the Y-Combinator var REDUCE = Y(make_reduc) // Define a function to count the number of items in a list var COUNT = list => REDUCE(list) // The list being reduced (dont_care => acc => SUCC(acc)) // The reduction function (ZERO_MAGNITUDE) // The accumulator start value // ******************************************************************** // Convert a positive integer to its Church encoding // Null must be explicitly tested for to avoid disappearing down the // rabbit hole of infinite recursion. This is because JavaScript will // coerce null to be zero; therefore, the "(n-1)" part of the // expression "next_qty_fn(lib.SUCC(qty_fn))(n-1)" will become 0-1 // which then leads to infinite recursion. // // This behaviour does however result in mapping null to ZERO, which // might produce misleading results... // ******************************************************************** var do_qty_fn = next_qty_fn => qty_fn => n => (n === 0 || n === null) ? qty_fn : next_qty_fn(SUCC(qty_fn))(n-1) var TO_CHURCH = Y(do_qty_fn)(ZERO_MAGNITUDE) // Define a FACTORIAL function var FACTORIAL = list => REDUCE(list) // The list being reduced (val => acc => MULTIPLY(TO_CHURCH(val))(acc)) // The reduction function now using Church numerals (UNIT_MAGNITUDE) // The accumulator start value // Define a SUM function var SUM = list => REDUCE(list) // The list being reduced (val => acc => ADD(TO_CHURCH(val))(acc)) // The reduction function now using Church numerals (ZERO_MAGNITUDE) // The accumulator start value // Fold left is simply a synonym for REDUCE // Fold right is simply a fold left performed on the reversed list var FOLDL = REDUCE var FOLDR = list => REDUCE(REVERSE(list)) return { adder : adder , multiplier : multiplier , str_concatenate: str_concatenate , asPlusChar : str_concatenate('+') , incr : adder(1) , decr : adder(-1) , push : push , magnitude : magnitude , to_string : to_string , to_boolean : to_boolean , is_empty : is_empty , is_last : is_last , is_pos : is_pos , str2list : str2list , list2str : list2str , array2list : array2list , list2array : list2array , PAIR : PAIR , TRUE : TRUE , FALSE : FALSE , HEAD : HEAD , TAIL : TAIL , EMPTY_LIST : EMPTY_LIST , IS_EMPTY : IS_EMPTY , IS_LAST : IS_LAST , SUCC : SUCC , PRED : PRED , NUMBER : NUMBER , ABS : ABS , SIGN : SIGN , ZERO_MAGNITUDE : ZERO_MAGNITUDE , UNIT_MAGNITUDE : UNIT_MAGNITUDE , HAS_ZERO_MAGNITUDE : HAS_ZERO_MAGNITUDE , HAS_UNIT_MAGNITUDE : HAS_UNIT_MAGNITUDE , SUCC_MAGNITUDE : SUCC_MAGNITUDE , PRED_MAGNITUDE : PRED_MAGNITUDE , ZERO : ZERO , PLUS_ONE : PLUS_ONE , PLUS_TWO : PLUS_TWO , PLUS_THREE : PLUS_THREE , PLUS_FOUR : PLUS_FOUR , PLUS_FIVE : PLUS_FIVE , MINUS_ONE : MINUS_ONE , MINUS_TWO : MINUS_TWO , MINUS_THREE : MINUS_THREE , MINUS_FOUR : MINUS_FOUR , MINUS_FIVE : MINUS_FIVE , ADD : ADD , MULTIPLY : MULTIPLY , POWER : POWER , SUBTRACT : SUBTRACT , NOT : NOT , AND : AND , OR : OR , XOR : XOR , IS_POS : IS_POS , IS_ZERO : IS_ZERO , IS_MINUS_ONE : IS_MINUS_ONE , IS_LTE : IS_LTE , IS_LT : IS_LT , Y : Y , REVERSE : REVERSE , MAP : MAP , REDUCE : REDUCE , COUNT : COUNT , TO_CHURCH : TO_CHURCH , FACTORIAL : FACTORIAL , SUM : SUM , FOLDL : FOLDL , FOLDR : FOLDR } }50:[] 48:{"id":"120889ee6f12aa02","slug":"mindshift-part-18","title":"Mindshift: Part 18","thumbnail":"c43c971b052f502129ebc5a61c4ec97367884e088ffe96fcea967c68a20657e2","access_level":"public","create_time":"$D2018-12-06T20:43:34.294Z","update_time":"$D2020-01-10T18:32:13.248Z","view_time":null,"first_public_time":"$D2018-12-07T17:45:20.075Z","has_unpublished_edits":null,"fork":false,"stars":0,"starred":false,"owner":{"type":"team","id":"224d52e60cffa1e1","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":"starter_2024","bio":"","followed_by_you":false,"follows_you":false},"version":245,"publish_version":245,"role":null,"authored":false,"authors":[{"type":"individual","id":"c2414676c206a65f","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":null,"bio":"","followed_by_you":false,"follows_you":false}],"members":[{"type":"individual","id":"c2414676c206a65f","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Mindshift: Part 18","cells":[{"id":0,"value":"$4c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":4,"value":"{\n var adder = val1 => val2 => val1 + val2\n var incr = adder(1)\n var to_integer = qtyFn => qtyFn(incr)(0)\n\n var ZERO = transform => start_value => start_value\n var SUCC = qtyFn => transform => start_value => transform(qtyFn(transform)(start_value))\n\n var ONE = SUCC(ZERO)\n var TWO = SUCC(ONE)\n var THREE = SUCC(TWO)\n\n // To add TWO and THREE together, we simply apply the SUCCessor function\n // TWO times to the starting value of THREE\n return `2 + 3 = ${to_integer(TWO(SUCC)(THREE))}`\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":11,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":25,"value":"ADD_MAGNITUDES = qtyFn1 => qtyFn2 => qtyFn1(lib.SUCC_MAGNITUDE)(qtyFn2)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":30,"value":"SUBTRACT_MAGNITUDES = qtyFn1 => qtyFn2 => qtyFn2(lib.PRED_MAGNITUDE)(qtyFn1)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":33,"value":"md`See the previous blog for a definition of the SUCC_MAGNITUDE and PRED_MAGNITUDE functions.\n\nIf you look in the table above, when we try to add two numbers having different signs, we need a \"less than or equal to\" operator that can operate on NUMBERs.\n\nHowever, we now run into a problem. Our previous definition of IS_LTE relied on the fact that we could not represent negative numbers. Therefore, if we tried to subtract a larger number from a smaller one, we would always get zero.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":173,"value":"_IS_LTE = val1 => val2 => lib.IS_ZERO(lib.SUBTRACT(val1)(val2))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":190,"value":"md`Now that we can represent negative numbers, such behaviour is no longer possible (or desirable). Therefore, the new version of IS_LTE must compare each NUMBER's reified magnitude and then return TRUE or FALSE.\n\nThis then leads to the fact that we need a new definition of the to_integer function that can reify a NUMBER instead of a \"naked\" abstract quantity function.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":201,"value":"to_integer = number => lib.magnitude(lib.ABS(number)) * lib.IS_POS(number)(1)(-1)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":36,"value":"IS_LTE = num1 => num2 => to_integer(num1) <= to_integer(num2) ? lib.TRUE : lib.FALSE","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":46,"value":"md`## Building the ADD Function\n\nNow we are in a position to implement the table shown above as the new version of the ADD function.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":51,"value":"$4e","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":55,"value":"md`Well that's a little more complicated than our previous version of ADD, but this is because we must now take into account first the dign of each number, and second, whether one number is bigger than the other.\n\nBefore testing the new ADD function, we need to adapt the to_integer function so that it can reify a NUMBER`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":130,"value":"md`Let's test that our new ADD function works:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":56,"value":"{\n return {\n \"ONE_plus_THREE\" : to_integer(ADD(lib.PLUS_ONE)(lib.PLUS_THREE))\n , \"TWO_plus_MINUS_FIVE\" : to_integer(ADD(lib.PLUS_TWO)(lib.MINUS_FIVE))\n , \"MINUS_ONE_plus_THREE\" : to_integer(ADD(lib.MINUS_ONE)(lib.PLUS_THREE))\n , \"MINUS_ONE_plus_MINUS_THREE\" : to_integer(ADD(lib.MINUS_ONE)(lib.MINUS_THREE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":136,"value":"md`Good, that works.\n\n## So, Is Subtraction Just As Complicated?\n\nFortunately, the answer is no because we know that the subtraction operation 5 - 3 is equivalent to the addition operation 5 + (-3).\n\nJust to demonstrate this to ourselves, lets write out the four permutations of signs in a subtraction operation, and their equivalent addition operation.\n\n| Subtraction\t| Is the same as |\n|:-:|:-:|:-:\n| +n1 - +n2 | +n1 + -n2\n| +n1 - -n2 | +n1 + +n2\n| -n1 - +n2 | -n1 + -n2\n| -n1 - -n2 | -n1 + +n2\n\n\nSo all we need to do to here is flip the sign of the second operand and subtraction can be performed using addition. Therefore, the new version of function SUBTRACT becomes an interface to function ADD:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":143,"value":"SUBTRACT =\n num1 =>\n num2 =>\n ADD(num1)\n (lib.NUMBER(lib.NOT(lib.SIGN(num2)))(lib.ABS(num2)))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":145,"value":"md`All we're doing inside function SUBTRACT is to pass the first parameter num1 unmodified to ADD and construct a new number from num2 using the NOT of its sign and its absolute value.\n\nLet's test that our new SUBTRACT works:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":149,"value":"{\n return {\n \"ONE_minus_THREE\" : to_integer(SUBTRACT(lib.PLUS_ONE)(lib.PLUS_THREE))\n , \"TWO_minus_MINUS_FIVE\" : to_integer(SUBTRACT(lib.PLUS_TWO)(lib.MINUS_FIVE))\n , \"MINUS_ONE_minus_THREE\" : to_integer(SUBTRACT(lib.MINUS_ONE)(lib.PLUS_THREE))\n , \"MINUS_TWO_minus_MINUS_THREE\" : to_integer(SUBTRACT(lib.MINUS_TWO)(lib.MINUS_THREE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":238,"value":"to_integer(lib.SUBTRACT(lib.PLUS_TWO)(lib.MINUS_ONE))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":157,"value":"md`So there we have it - the ability to perform subtraction using only the addition operator.\n\nIn the next blog, we'll look at multiplication and division.\n\nChris W\n\n\n\n \n

\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":26,"value":"$4f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W50","stdlib":"1"}} 24:null