Ethiopian multiplication: Difference between revisions

Use these functions to '''create a function that does Ethiopian multiplication'''.

 

 

;References:

=={{header|11l}}==

{{trans|Python}}

R x I/ 2

 

R result

 

 

{{out}}

less elegant, so I've done it this way as a sort of compromise.

 

jmp demo

;;; HL = BC * DE

jmp 5

db '*****'

{{out}}

<pre>578</pre>

=={{header|ACL2}}==

 

(defun halve (x)

0

y)

 

=={{header|Action!}}==

INT res

 

res=EthopianMult(17,34)

PrintF("Result is %I",res)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Ethiopian_multiplication.png Screenshot from Atari 8-bit computer]

=={{header|ActionScript}}==

{{works with|ActionScript|2.0}}

return ((a-(a%2))/2);

}

trace("="+" "+r);

}

ex. Ethiopian(17,34);

17 34

 

=={{header|Ada}}==

with ada.text_io;use ada.text_io;

 

begin

put_line (mul (17,34)'img);

 

=={{header|Aime}}==

{{trans|C}}

halve(integer &x)

{

 

return 0;

17 34 kept

8 68 struck

 

<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - missing printf and FORMAT}} -->

PROC doublit = (REF INT x)VOID: x := ABS(BIN x SHL 1);

PROC iseven = (#CONST# INT x)BOOL: NOT ODD x;

(

printf(($g(0)l$, ethiopian(17, 34, TRUE)))

ethiopian multiplication of 17 by 34

0017 000034 kept

 

=={{header|ALGOL-M}}==

BEGIN

 

WRITE(ETHIOPIAN(17,34,YES));

 

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% returns half of a %

integer procedure halve ( integer value a ) ; a div 2;

write( " ", m )

end

{{out}}

<pre>

See also: [[Repeat_a_string#AppleScript]]

 

{ethMult(17, 34), ethMult("Rhind", 9)}

end repeat

return plus(o, m) of fns

 

{{Out}}

 

<pre>{578, "RhindRhindRhindRhindRhindRhindRhindRhindRhind"}</pre>

 

=={{header|Arturo}}==

 

double: function [x]-> shl x 1

 

 

print ethiopian 17 34

 

{{out}}

 

=={{header|AutoHotkey}}==

 

; func definitions:

Ethiopian2( a, b, r = 0 ) { ;omit r param on initial call

return a==1 ? r+b : Ethiopian2( half(a), double(b), !isEven(a) ? r+b : r )

 

=={{header|AutoIt}}==

Func Halve($x)

Return Int($x/2)

 

MsgBox(0, "Ethiopian multiplication of 17 by 34", Ethiopian(17, 34) )

 

=={{header|AWK}}==

Implemented without the tutor.

{

return int(x/2)

BEGIN {

print ethiopian(17, 34)

 

=={{header|BASIC}}==

 

==={{header|ASIC}}===

REM Ethiopian multiplication

X = 17

ISEVEN = 1 - ISEVEN

RETURN

{{out}}

<pre>

Works with QBasic. While building the table, it's easier to simply not print unused values, rather than have to go back and strike them out afterward. (Both that and the actual adding happen in the "IF NOT (isEven(x))" block.)

 

DECLARE FUNCTION doub% (a AS INTEGER)

DECLARE FUNCTION isEven% (a AS INTEGER)

FUNCTION isEven% (a AS INTEGER)

isEven% = (a MOD 2) - 1

8

4

2

1 544

 

==={{header|BBC BASIC}}===

y% = 34

DEF FNhalve(A%) = A% DIV 2

8 ---

4 ---

1 544

===

 

==={{header|FreeBASIC}}===

Var answer="0"+y

Var addcarry=0

Sleep

Biggest Smallest

 

 

==={{header|GW-BASIC}}===

 

==={{header|Liberty BASIC}}===

y = 34

msg$ = str$(x) + " * " + str$(y) + " = "

Function doubleInt(num)

doubleInt = Int(num * 2)

 

==={{header|Microsoft Small Basic}}===

y = 34

tot = 0

TextWindow.Write("=")

TextWindow.CursorLeft = 10

 

{{trans|Modula-2}}

{{works with|Nascom ROM BASIC|4.7}}

20 DEF FND(A)=2*A

30 DEF FNH(A)=INT(A/2)

50 X=17

60 Y=34

1000 S$=STR$(NR)

1010 PRINT SPC(9-LEN(S$));S$;

{{out}}

8

4

2

1 544

 

==={{header|PureBasic}}===

ProcedureReturn (x & 1) ! 1

EndProcedure

Input()

CloseConsole()

{{out}}

Ethiopian multiplication of 17 and 34 ... equals 578

It became apparent that according to the way the Ethiopian method is described above it can't produce a correct result if the first multiplicand (the one being repeatedly halved) is negative. I've addressed that in this variation. If the first multiplicand is negative then the resulting sum (which may already be positive or negative) is negated.

ProcedureReturn (x & 1) ! 1

EndProcedure

Input()

CloseConsole()

{{out}}

Ethiopian multiplication of -17 and 34 ... equals -578

 

==={{header|QB64}}===

 

SUB twice (n AS LONG)

WEND

multiply& = result

{{out}}

 

==={{header|Sinclair ZX81 BASIC}}===

Requires at least 2k of RAM. The specification is emphatic about wanting named functions: in a language where user-defined functions do not exist, the best we can do is to use subroutines and assign their line numbers to variables. This allows us to <code>GOSUB HALVE</code> instead of having to <code>GOSUB 320</code>. (It would however be more idiomatic to avoid using subroutines at all, for simple operations like these, and to refer to them by line number if they were used.)

20 LET DOUBLE=340

30 LET EVEN=360

360 LET Y=X/2=INT (X/2)

370 RETURN

{{in}}

<pre>17

 

==={{header|Tiny BASIC}}===

REM Ethiopian multiplication

LET X=17

REM A - param.; E - result (0 - false)

400 LET E=A-(A/2)*2

{{out}}

8, 68

4, 136

1, 544 (kept)

------------

 

==={{header|True BASIC}}===

A translation of BBC BASIC. True BASIC does not have Boolean operations built-in.

! True BASIC v6.007

PROGRAM EthiopianMultiplication

DEF FNhalve(A) = INT(A / 2)

DEF FNeven(A) = MOD(A+1,2)

 

==={{header|XBasic}}===

{{trans|Modula-2}}

{{works with|Windows XBasic}}

PROGRAM "ethmult"

VERSION "0.0000"

RETURN a&& MOD 2 = 0

END FUNCTION

{{out}}

8

4

2

1 544

 

=={{header|Batch File}}==

@echo off

:: Pick 2 random, non-zero, 2-digit numbers to send to :_main

set /a modint=%int% %% 2

exit /b %modint%

 

{{out}}

 

=={{header|BCPL}}==

 

let halve(i) = i>>1

emulr(halve(x), double(y), even(x) -> ac, ac + y)

{{out}}

<pre>578</pre>

 

=={{header|Bracmat}}==

& (double=.2*!arg)

& (isEven=.mod$(!arg.2):0)

)

& out$(mul$(17.34))

Output

<pre>578</pre>

=={{header|BQN}}==

 

Halve ← ⌊÷⟜2

Odd ← 2⊸|

}

 

 

To avoid using a while loop, the iteration count is computed beforehand.

 

=={{header|C}}==

#include <stdbool.h>

 

printf("%d\n", ethiopian(17, 34, true));

return 0;

 

=={{header|C sharp|C#}}==

{{works with|c sharp|C#|3+}}<br>

{{libheader|System.Linq}}<br>

using System;

using System.Linq;

}

}

 

=={{header|C++}}==

Here is such an implementation without tutor, since there is no mechanism in C++ to output

messages during program compilation.

struct Half

{

std::cout << EthiopianMultiplication<17, 54>::Result << std::endl;

return 0;

 

=={{header|Clojure}}==

(bit-shift-right n 1))

 

(if (even a)

(recur (halve a) (twice b) r)

 

=={{header|CLU}}==

return(n/2)

end halve

po: stream := stream$primary_output()

stream$putl(po, int$unparse(e_mul(17, 34)))

{{out}}

<pre>578</pre>

{{works with|OpenCOBOL|1.1}}

In COBOL, ''double'' is a reserved word, so the doubling functions is named ''twice'', instead.

 

IDENTIFICATION DIVISION.

SUBTRACT m FROM 1 GIVING m END-SUBTRACT

GOBACK.

 

=={{header|CoffeeScript}}==

halve = (n) -> Math.floor n / 2

double = (n) -> n * 2

for j in [0..100]

throw Error("broken for #{i} * #{j}") if multiply(i,j) != i * j

 

=={{header|ColdFusion}}==

Version with as a function of functions:

 

<cfargument name="number" type="numeric" required="true">

<cfset answer = number * 2>

 

 

<cfset Number_B = 34>

<cfset Result = 0>

...equals #Result#

 

Sample output:<pre>

Ethiopian multiplication of 17 and 34...

=={{header|Common Lisp}}==

 

(flet ((halve (n) (floor n 2))

(double (n) (* n 2))

(l l (halve l))

(r r (double r)))

 

=={{header|D}}==

in {

assert(n1 >= 0, "Multiplier can't be negative");

 

writeln("17 ethiopian 34 is ", ethiopian(17, 34));

17 ethiopian 34 is 578

 

=={{header|dc}}==

[ 2 / ] sH [ Define "halve" function in register H ]sx

[ 2 * ] sD [ Define "double" function in register D ]sx

 

[ Demo by multiplying 17 and 34 ]sx

{{out}}

578

=={{header|Delphi}}==

See [https://rosettacode.org/wiki/Ethiopian_multiplication#Pascal Pascal].

 

=={{header|E}}==

def double(&x) { x *= 2 }

def even(x) { return x %% 2 <=> 0 }

}

return ab

 

=={{header|EasyLang}}==

.

 

=={{header|Eiffel}}==

class

APPLICATION

end

 

{{out}}

<pre>

=={{header|Ela}}==

Translation of Haskell:

halve x = x `div` 2

(iterate double b)

 

578

 

=={{header|Elixir}}==

{{trans|Erlang}}

def halve(n), do: div(n, 2)

end

 

 

{{out}}

=={{header|Emacs Lisp}}==

Emacs Lisp has <code>cl-evenp</code> in cl-lib.el (its Common Lisp library), but for the sake of completeness the desired effect is achieved here via <code>mod</code>.

(= (mod n 2) 0))

(defun halve (n)

(setq l (halve l))

(setq r (double r)))

 

=={{header|Erlang}}==

-export([multiply/2]).

 

false ->

multiply(halve(LHS),double(RHS),Acc+RHS)

 

=={{header|ERRE}}==

 

FUNCTION EVEN(A)

PRINT("=",TOT)

END PROGRAM

{{out}}

17 34

 

=={{header|Euphoria}}==

return floor(n/2)

end function

 

printf(1,"\nPress Any Key\n",{})

 

=={{header|F Sharp|F#}}==

let halve n = n / 2

let double n = n * 2

else if even n then loop (halve n) (double m) result

else loop (halve n) (double m) (result + m)

 

=={{header|Factor}}==

IN: ethiopian-multiplication

 

[ odd? [ + ] [ drop ] if ] 2keep

[ double ] [ halve ] bi*

 

=={{header|FALSE}}==

[2*]d:

[$2/2*-]o:

[0[@$][$o;![@@\$@+@]?h;!@d;!@]#%\%]m:

 

=={{header|Forth}}==

Halve and double are standard words, spelled '''2/''' and '''2*''' respectively.

: e* ( x y -- x*y )

dup 0= if nip exit then

over 2* over 2/ recurse

 

=={{header|Fortran}}==

implicit none

 

end function ethiopic

 

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import "fmt"

func main() {

fmt.Printf("17 ethiopian 34 = %d\n", ethMulti(17, 34))

 

=={{header|Haskell}}==

===Using integer (+)===

import Control.Monad (join)

 

 

main :: IO ()

{{Out}}

<pre>*Main> ethiopicmult 17 34

Logging the stages of the '''unfoldr''' and '''foldr''' applications:

 

import Data.Tuple (swap)

import Debug.Trace (trace)

main = do

print $ ethMult 17 34

{{Out}}

<pre>halve: (8,1)

This additional generality means that our '''ethMult''' function can now replicate a string n times as readily as it multiplies an integer n times, or raises an integer to the nth power.

 

import Data.List (unfoldr)

import Data.Monoid (getProduct, getSum)

 

----------------- ETHIOPIAN MULTIPLICATION ---------------

ethMult n m =

foldr addedWhereOdd mempty $

zip (unfoldr half n) $ iterate (join (<>)) m

 

--------------------------- TEST -------------------------

<> (getProduct <$> ([ethMult 17] <*> [3, 4]))

print $ ethMult 17 "34"

{{Out}}

<pre>578

 

=={{header|HicEst}}==

END ! of "main"

 

FUNCTION isEven( x )

isEven = MOD(x, 2) == 0

 

=={{header|Icon}} and {{header|Unicon}}==

while ethiopian(integer(get(arglist)),integer(get(arglist))) # multiply successive pairs of command line arguments

end

procedure even(i)

return ( i % 2 = 0, i )

local p,w

w := *j+3

write(right("=",w),right(p,w))

return p

 

=={{header|J}}==

halve =: %&2 NB. or the primitive -:

odd =: 2&|

 

 

'''Example''':

17 34 68 136 272

 

 

77

7 ethio _11

_77

_7 ethio _11

 

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.Map;

import java.util.Scanner;

return (num & 1) == 0;

}

* This method will use ethiopian styled multiplication.

* @param a Any non-negative integer.

}

return result;

 

=={{header|JavaScript}}==

halve : function ( n ){ return Math.floor(n/2); },

}

}

 

 

 

 

var o = !isNaN(m) ? 0 : ''; // same technique works with strings

if (n < 1) return o;

}

 

 

{{Out}}

Note that the same function will also multiply strings with some efficiency, particularly where n is larger. See [[Repeat_a_string]]

 

 

{{Out}}

The following implementation is intended for jq 1.4 and later.

 

 

def double: 2 * .;

| select( .[0] | isEven | not)

| .[1] ) as $i

 

=={{header|Jsish}}==

From Javascript entry.

var eth = {

halve : function(n) { return Math.floor(n / 2); },

eth.mult(17,34) ==> 578

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

'''Helper functions''' (type stable):

double(x::Integer) = Int8(2) * x

 

'''Main function''':

r = 0

while a > 0

end

 

 

'''Array version''' (more similar algorithm to the one from the task description):

A = [a]

B = [b]

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

fun halve(n: Int) = n / 2

println("17 x 34 = ${ethiopianMultiply(17, 34)}")

println("99 x 99 = ${ethiopianMultiply(99, 99)}")

 

{{out}}

99 x 99 = 9801

</pre>

 

=={{header|Lambdatalk}}==

A translation from the javascript entry.

 

{def halve {lambda {:n} {floor {/ :n 2}}}}

-> halve

-> 578

 

 

=={{header|Limbo}}==

 

include "sys.m";

return product;

}

 

=={{header|Locomotive Basic}}==

 

20 DEF FNhalf(a)=INT(a/2)

30 DEF FNdouble(a)=2*a

80 x=FNhalf(x):y=FNdouble(y)

90 WEND

 

Output:

 

=={{header|Logo}}==

output ashift :x 1

end

[output eproduct halve :x double :y] ~

[output :y + eproduct halve :x double :y]

 

=={{header|LOLCODE}}==

 

HOW IZ I Halve YR Integer

 

VISIBLE I IZ EthiopianProdukt YR 17 AN YR 34 MKAY

 

Output: <pre>578</pre>

 

=={{header|Lua}}==

return a/2

end

end

 

 

=={{header|M2000 Interpreter}}==

Module EthiopianMultiplication{

Form 60, 25

}

EthiopianMultiplication

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

IntegerDoubling[x_]:=x*2;

OddInteger OddQ

Total[Select[NestWhileList[{IntegerHalving[#[[1]]],IntegerDoubling[#[[2]]]}&, {x,y}, (#[[1]]>1&)], OddQ[#[[1]]]&]][[2]]

 

 

Output:

 

halveInt.m:

result = idivide(number,2,'floor');

 

 

doubleInt.m:

 

result = times(2,number);

 

 

isEven.m:

function trueFalse = isEven(number)

 

trueFalse = logical( mod(number,2)==0 );

 

ethiopianMultiplication.m:

%Generate columns

answer = sum(multiplier);

 

Sample input: (with data type coercion)

 

ans =

 

578

 

=={{header|Metafont}}==

Implemented without the ''tutor''.

vardef double(expr x) = x*2 enddef;

vardef iseven(expr x) = if (x mod 2) = 0: true else: false fi enddef;

 

show( (17 ethiopicmult 34) );

 

=={{header|МК-61/52}}==

ИП0 1 - x#0 29

ИП1 2 * П1

2 / {x} x#0 04 ИП2 ИП1 + П2

БП 04

 

=={{header|MMIX}}==

In order to assemble and run this program you'll have to install MMIXware from [http://www-cs-faculty.stanford.edu/~knuth/mmix-news.html]. This provides you with a simple assembler, a simulator, example programs and full documentation.

 

B IS 34

 

% 'str' points to the start of the result

TRAP 0,Fputs,StdOut % output answer to stdout

Assembling:

<pre>~/MIX/MMIX/Progs> mmixal ethiopianmult.mms</pre>

=={{header|Modula-2}}==

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

MODULE EthiopianMultiplication;

 

WriteLn;

END EthiopianMultiplication.

{{out}}

<pre>

=={{header|Modula-3}}==

{{trans|Ada}}

 

IMPORT IO, Fmt;

BEGIN

IO.Put("17 times 34 = " & Fmt.Int(Multiply(17, 34)) & "\n");

 

HALVE(I)

;I should be an integer

Write !,?W,$Justify(A,W),!

Kill W,A,E,L

USER>D E2^ROSETTA(1439,7)

Multiplying two numbers:

 

=={{header|Nemerle}}==

using System.Console;

 

WriteLine("By Ethiopian multiplication, 17 * 34 = {0}", Multiply(17, 34));

}

 

=={{header|NetRexx}}==

{{trans|REXX}}

options replace format comments java crossref savelog symbols nobinary

 

 

method iseven(x) private static

 

=={{header|Nim}}==

proc double(x: int): int = x * 2

proc odd(x: int): bool = x mod 2 != 0

y = double y

 

{{out}}

 

=={{header|Objeck}}==

use Collection;

 

return (num and 1) = 0;

}

 

=={{header|Object Pascal}}==

interface

 

end;

begin

 

uses

begin

WriteLn('17 * 34 = ', Ethiopian(17, 34))

17 * 34 = 578

 

=={{header|Objective-C}}==

Using class methods except for the generic useful function <tt>iseven</tt>.

 

BOOL iseven(int x)

}

return 0;

 

=={{header|OCaml}}==

the right column on-the-fly, like in the C version.

The function takes "halve" and "double" operators and "is_even" predicate as arguments,

of values in the right column in the original algorithm. But the "add"

me do something else, see for example the RosettaCode page on

 

=={{header|Octave}}==

r = floor(a/2);

endfunction

endfunction

 

 

=={{header|Oforth}}==

isEven is already defined for Integers.

 

: double 2 * ;

dup ifZero: [ nip return ]

over double over halve ethiopian

 

{{out}}

=={{header|Ol}}==

 

(define (ethiopian-multiplication l r)

(let ((even? (lambda (n)

 

(print (ethiopian-multiplication 17 34))

 

{{out}}

 

=={{header|Oz}}==

fun {Halve X} X div 2 end

fun {Double X} X * 2 end

fun {Sum Xs} {FoldL Xs Number.'+' 0} end

in

 

=={{header|PARI/GP}}==

double(n)=2*n;

even(n)=!(n%2);

b=double(b));

d

 

=={{header|Pascal}}==

{$IFDEF FPC}

{$MODE DELPHI}

begin

Write(Ethiopian(17, 34))

 

=={{header|Perl}}==

 

sub halve { int((shift) / 2); }

}

 

 

=={{header|Phix}}==

{{Trans|Euphoria}}

<span style="color: #008080;">function</span> <span style="color: #000000;">emHalf</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"emMultiply(%d,%d) = %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">17</span><span style="color: #0000FF;">,</span><span style="color: #000000;">34</span><span style="color: #0000FF;">,</span><span style="color: #000000;">emMultiply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">17</span><span style="color: #0000FF;">,</span><span style="color: #000000;">34</span><span style="color: #0000FF;">)})</span>

 

=={{header|PHP}}==

function halve($x)

{

echo ethiopicmult(17, 34, true), "\n";

 

ethiopic multiplication of 17 and 34

17, 34 kept

578

Object Oriented version:

 

class ethiopian_multiply {

 

echo ethiopian_multiply::init(17, 34);

 

=={{header|PicoLisp}}==

(/ N 2) )

 

X (halve X)

Y (double Y) ) )

 

=={{header|Pike}}==

{

int halve(int n) { return n/2; };

while(l);

return product;

 

=={{header|PL/I}}==

declare (L(30), R(30)) fixed binary;

declare (i, s) fixed binary;

odd: procedure (k) returns (bit (1));

return (iand(k, 1) ^= 0);

 

=={{header|PL/SQL}}==

This code was taken from the ADA example above - very minor differences.

 

function multiply

dbms_output.put_line(ethiopian.multiply(17, 34));

end;

 

=={{header|Plain English}}==

\

\To cut a number in half:

Double the other number.

Repeat.

{{out}}

<pre>

 

=={{header|Powerbuilder}}==

end function

 

// example call

long ll_answer

 

=={{header|PowerShell}}==

===Traditional===

param ([int]$value)

return [bool]($value % 2 -eq 0)

}

 

===Pipes with Busywork===

This uses several PowerShell specific features, in functions everything is returned automatically, so explicitly stating return is unnecessary. type conversion happens automatically for certain types, [int] into [boolean] maps 0 to false and everything else to true. A hash is used to store the values as they are being written, then a pipeline is used to iterate over the keys of the hash, determine which are odd, and only sum those. The three-valued ForEach-Object is used to set a start expression, an iterative expression, and a return expression.

{

[math]::floor( $rhs / 2 )

}

 

 

=={{header|Prolog}}==

=== Traditional ===

 

double(X,Y) :- Y is 2*X.

is_even(X) :- 0 is X mod 2.

columns(First,Second,Left,Right),

maplist(contribution,Left,Right,Contributions),

 

 

Using the same definitions as above for "halve/2", "double/2" and "is_even/2" along with an SWI-Prolog [http://www.swi-prolog.org/pack/list?p=func pack for function notation], one might write the following solution

 

 

% halve/2, double/2, is_even/2 definitions go here

ethiopian(First,Second,Sum0,Sum) :-

Sum1 is Sum0 + Second*(First mod 2),

 

 

 

This is a CHR solution for this problem using Prolog as the host language. Code will work in SWI-Prolog and YAP (and possibly in others with or without some minor tweaking).

 

:- use_module(library(chr)).

test :-

mul(17, 34, Z), !,

 

 

:- use_module(library(chr)).

test :-

mul(17, 34, Z),

 

=={{header|Python}}==

===Python: With tutor===

 

def halve(x):

if tutor:

print()

 

Sample output

Without the tutorial code, and taking advantage of Python's lambda:

 

double = lambda x: x*2

even = lambda x: not x % 2

multiplicand = double(multiplicand)

 

 

===Python: With tutor. More Functional===

 

from itertools import izip, takewhile

if tutor:

show_result(result)

>>> ethiopian(17, 34)

Multiplying 17 by 34 using Ethiopian multiplication:

 

Avoiding the use of the multiplication operator, and defining a catamorphism applied over an anamorphism.

 

from functools import reduce

if __name__ == '__main__':

main()

{{Out}}

<pre>halve: (8, 1)

Extended to handle negative numbers.

 

 

[ 1 << ] is double ( n --> n )

swap even

iff nip else + ]

 

=={{header|R}}==

===R: With tutor===

double <- function(a) a*2

iseven <- function(a) (a%%2)==0

}

 

 

===R: Without tutor===

Simplified version.

halve <- function(a) floor(a/2)

double <- function(a) a*2

 

print(ethiopicmult(17,34))

 

=={{header|Racket}}==

 

(define (halve i) (quotient i 2))

[else (+ y (ethiopian-multiply (halve x) (double y)))]))

 

 

=={{header|Raku}}==

(formerly Perl 6)

sub double (Int $n is rw) { $n *= 2 }

sub even (Int $n --> Bool) { $n %% 2 }

}

 

{{out}}

578

More succinctly using implicit typing, primed lambdas, and an infinite loop:

my &halve = * div= 2;

my &double = * *= 2;

}

 

More succinctly still, using a pure functional approach (reductions, mappings, lazy infinite sequences):

sub double { $^n * 2 }

sub even { $^n %% 2 }

}

 

 

=={{header|Rascal}}==

 

public int halve(int n) = n/2;

}

return result;

 

=={{header|Red}}==

 

halve: function [n][n >> 1]

]

 

{{out}}

<pre>

 

=={{header|Relation}}==

function half(x)

set result = floor(x/2)

run ethiopian_mul(17,34)

print

 

=={{header|REXX}}==

These two REXX versions properly handle negative integers.

===sans error checking===

numeric digits 3000 /*handle some gihugeic integers. */

parse arg a b . /*get two numbers from the command line*/

double: return arg(1) * 2 /* * is REXX's multiplication. */

halve: return arg(1) % 2 /* % " " integer division. */

'''output''' &nbsp; when the following input is used: &nbsp; <tt> 30 &nbsp; -7 </tt>

<pre>

 

Note that the 2^nd number needn't be an integer, any valid number will work.

numeric digits 3000 /*handle some gihugeic integers. */

parse arg a b _ . /*get two numbers from the command line*/

halve: return arg(1) % 2 /* % " " integer division. */

isEven: return arg(1) // 2 == 0 /* // " " division remainder.*/

'''output''' &nbsp; when the following input is used: &nbsp; <tt> 200 &nbsp; 0.333 </tt>

<pre>

 

=={{header|Ring}}==

x = 17

y = 34

func halve n return floor(n / 2)

func even n return ((n & 1) = 0)

Output:

<pre>

578

</pre>

 

=={{header|Ruby}}==

Iterative and recursive implementations here.

I've chosen to highlight the example 20*5 which I think is more illustrative.

 

# iterative

$DEBUG = true # $DEBUG also set to true if "-d" option given

a, b = 20, 5

 

{{out}}

 

A test suite:

class EthiopianTests < Test::Unit::TestCase

def test_iter1; assert_equal(578, ethopian_multiply(17,34)); end

def test_rec5; assert_equal(0, rec_ethopian_multiply(5,0)); end

def test_rec6; assert_equal(0, rec_ethopian_multiply(0,5)); end

<pre>Run options:

 

 

=={{header|Rust}}==

2*a

}

println!("---------------------------------");

println!("\t {}", output);

 

{{out}}

 

=={{header|S-BASIC}}==

$constant true = 0FFFFH

$constant false = 0

print ethiopian(17,34,true)

 

{{out}}

<pre>Multiplying 17 times 34

The fourth uses recursion.

 

def ethiopian(i:Int, j:Int):Int=

pairIterator(i,j).filter(x=> !isEven(x._1)).map(x=>x._2).foldLeft(0){(x,y)=>x+y}

def next={val r=i; i=(halve(i._1), double(i._2)); r}

}

 

=={{header|Scheme}}==

In Scheme, <code>even?</code> is a standard procedure.

(quotient num 2))

 

 

(display (mul-eth 17 34))

Output:

578

Ethiopian Multiplication is another name for the peasant multiplication:

 

begin

a *:= 2;

double(b);

end while;

 

Original source (without separate functions for doubling, halving, and checking if a number is even): [http://seed7.sourceforge.net/algorith/math.htm#peasantMult]

 

=={{header|Sidef}}==

func halve (n) { n >> 1 }

func isEven (n) { n&1 == 0 }

}

 

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

double [ ^ self * 2 ]

halve [ ^ self // 2 ]

]

ethiopianMultiplyBy: aNumber [ ^ self ethiopianMultiplyBy: aNumber withTutor: false ]

 

 

=={{header|SNOBOL4}}==

define('halve(num)') :(halve_end)

halve eq(num,1) :s(freturn)

l = halve(l) :s(next)

stop output = s

 

=={{header|SNUSP}}==

 

| | /-\ /recurse\ #/?\ zero

$>,@/>,@/?\<=zero=!\?/<=print==!\@\>?!\@/<@\.!\-/

\>+<-/ | \=<<<!/====?\=\ | double

! # | \<++>-/ | |

 

This is possibly the smallest multiply routine so far discovered for SNUSP.

 

=={{header|Soar}}==

# multiply takes ^left and ^right numbers

# and a ^return-to

^answer <a>)

-->

 

=={{header|Swift}}==

 

func ethiopian(var #int1:Int, var #int2:Int) -> Int {

}

 

{{out}}

<pre>578</pre>

 

=={{header|Tcl}}==

proc function {name arguments body} {

uplevel 1 [list proc tcl::mathfunc::$name $arguments [list expr $body]]

}

return [expr {mult($a,$b)}]

Ethiopian multiplication of 17 and 34

17 34 KEPT

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

ASK "insert number1", nr1=""

PRINT line

PRINT sum

ethopian multiplication of 17 and 34

17 34 kept

====================

578

 

=={{header|UNIX Shell}}==

 

{{works with|Bourne Shell}}

{

expr "$1" / 2

 

ethiopicmult 17 34

 

While breaking if the --posix flag is passed to bash, the following alternative script avoids the *, /, and % operators. It also uses local variables and built-in arithmetic.

{{works with|zsh}}

 

(( $1 >>= 1 ))

}

 

multiply 17 34

 

==={{header|C Shell}}===

alias double '@ \!:1 *= 2'

alias is_even '@ \!:1 = ! ( \!:2 % 2 )'

multiply p 17 34

echo $p

 

=={{header|Ursala}}==

check the parity, double a given natural number, or perform truncating division by two. These

functions are normally imported from the nat library but defined here explicitly for

double = ~&iNiCB

 

 

578

 

# one to '''double an integer''', and

# one to '''state if an integer is even'''.

lngHalve = Nb / 2

End Function

Private Function IsEven(Nb As Long) As Boolean

IsEven = (Nb Mod 2 = 0)

Use these functions to create a function that does Ethiopian multiplication.

The first function below is a non optimized function :

Dim Left_Hand_Column As New Collection, Right_Hand_Column As New Collection, i As Long, temp As Long

 

Next

Ethiopian_Multiplication_Non_Optimized = temp

This one is better :

Do

If Not IsEven(First) Then Mult_Eth = Mult_Eth + Second

Loop While First >= 1

Ethiopian_Multiplication = Mult_Eth

Then you can call one of these functions like this :

Dim result As Long

result = Ethiopian_Multiplication(17, 34)

'result = Ethiopian_Multiplication_Non_Optimized(17, 34)

Debug.Print result

 

=={{header|VBScript}}==

<code>option explicit</code> makes sure that all variables are declared.

 

class List

multiply = total

end function

wscript.echo multiply(17,34)

578

 

=={{header|Wren}}==

 

var double = Fn.new { |n| n * 2 }

 

System.print("17 x 34 = %(ethiopian.call(17, 34))")

 

{{out}}

=={{header|x86 Assembly}}==

{{works with|nasm}}, linking with the C standard library and start code.

global main

 

db "struck", 0

kepttxt

===Smaller version===

Using old style 16 bit registers created in debug

to test if the value is even

 

jz Even

Odd:

 

1BDC:0100 6A11 PUSH 11 ;17 Put operands on the stack

1BDC:0128 C3 RET ; return with the result in AX

 

 

=={{header|XPL0}}==

 

func Halve(N); \Return half of N

Product:= EthiopianMul(1234, 5678);

ChOut(0, 9); IntOut(0, Product); CrLf(0);

<pre>17 34

8 0

--------

7006652</pre>

 

=={{header|zkl}}==

Trying to duplicate the task as stated, using columns.

isEven is a integer method.

halve :=fcn(n){ n/2 };

double :=fcn(n){ n+n };

lr.filter(fcn([(l,r)]){ (not l.isEven) }); // strike out even left rows

.reduce(fcn(sum,[(l,r)]){ sum + r },0); // sum right column

println(ethiopianMultiply(l,r)," ",ethiopianMultiply(r,l));

{{out}}

<pre>

 

=={{header|Z80 Assembly}}==

 

ld hl,17

align 8 ;aligns Column_2 to the nearest 256 byte boundary. This makes offsetting easier.

Column_2:

 

{{out}}

=={{header|ZX Spectrum Basic}}==

{{trans|GW-BASIC}}

20 DEF FN h(a)=INT (a/2)

30 DEF FN d(a)=2*a

80 PRINT "---"

90 LET x=FN h(x): LET y=FN d(y): GO TO 50

 

[[Category:Arithmetic]]