zettacode 0.1.0 → 0.1.1

data/zettacode.files/arithmetic.integer/mercury.txt

@@ -1,44 +1,44 @@
 
-:- u _.
-:- fc.
-
-:- _u .
-:-  (::, ::u)  .
-
-:- .
-:- _u , , .
-
-(!IO) :-
-    .c__u(A, !IO),
-    ( f
-        A = [AS, BS],
-        ._(AS, A),
-        ._(BS, B)
-      
-        .f("A + B = %\", [(A + B)], !IO),
-        .f("A - B = %\", [(A - B)], !IO),
-        .f("A * B = %\", [(A * B)], !IO),
-
-        % D: u  z.
+:- module arith_int.
+:- interface.
+
+:- import_module io.
+:- pred main(io::di, io::uo) is det.
+
+:- implementation.
+:- import_module int, list, string.
+
+main(!IO) :-
+    io.command_line_arguments(Args, !IO),
+    ( if
+        Args = [AStr, BStr],
+        string.to_int(AStr, A),
+        string.to_int(BStr, B)
+      then
+        io.format("A + B = %d\n", [i(A + B)], !IO),
+        io.format("A - B = %d\n", [i(A - B)], !IO),
+        io.format("A * B = %d\n", [i(A * B)], !IO),
+
+        % Division: round towards zero.
         %
-        .f("A  B = %\", [(A  B)], !IO),
+        io.format("A / B = %d\n", [i(A / B)], !IO),
 
-        % D: u  u f.
+        % Division: round towards minus infinity.
         %
-        .f("A  B = %\", [(A  B)], !IO), 
+        io.format("A div B = %d\n", [i(A div B)], !IO), 
     
-        % Muu: X  Y = X - (X  Y) * Y.
+        % Modulus: X mod Y = X - (X div Y) * Y.
         %
-        .f("A  B = %\", [(A  B)], !IO),
+        io.format("A mod B = %d\n", [i(A mod B)], !IO),
 
-        % R: X  Y = X - (X  Y) * Y.
+        % Remainder: X rem Y = X - (X / Y) * Y.
         %
-        .f("A  B = %\", [(A  B)], !IO),
+        io.format("A rem B = %d\n", [i(A rem B)], !IO),
 
-        % E   u  fuc .2.
+        % Exponentiation is done using the function int.pow/2.
         %
-        .f("A `` B = %\", [(A `` B)], !IO)
-      
-        .__u(1, !IO)
+        io.format("A `pow` B = %d\n", [i(A `pow` B)], !IO)
+      else
+        io.set_exit_status(1, !IO)
     ).
 

data/zettacode.files/arithmetic.integer/metafont.txt

@@ -1,19 +1,19 @@
 
- []
- "u ub : "
-1 := 
- "u ub b: "
-2 := 
- := c 1
-b := c 2
+string s[];
+message "input number a: ";
+s1 := readstring;
+message "input number b: ";
+s2 := readstring;
+a := scantokens s1;
+b := scantokens s2;
 
-f u( ) =
-   " "    " b = "  c( c() b) f
-
-u("+")
-u("-")
-u("*")
-u("")
-u("")
+def outp(expr op) =
+  message "a " & op & " b = " & decimal(a scantokens(op) b) enddef;
 
+outp("+");
+outp("-");
+outp("*");
+outp("div");
+outp("mod");
 
+end

data/zettacode.files/arithmetic.integer/min.txt

@@ -1,5 +1,5 @@
-{{ ||0.19.3}}
-(coc du - ' d "$1 - $2" w % u!) :ow
+{{works with|min|0.19.3}}
+(concat dup -> ' prepend "$1 -> $2" swap % puts!) :show
 
-("E  "  ) 2  ' 
-('+ '- '* ' ') qu- (' cc)  c
+("Enter an integer" ask int) 2 times ' prepend
+('+ '- '* 'div 'mod) quote-map ('show concat) map cleave

data/zettacode.files/arithmetic.integer/ml-i.txt

@@ -1,18 +1,18 @@
-MLI     f ' u'  , 
-  uu  u  ' uu'  .
+ML/I will read two integers from 'standard input' or similar, 
+and then output the results to 'standard output' or similar.
 
- =""MCSKIP "WITH" NL
-"" AcI
-"" u c  u  1,    2
-MCSKIP MT,
+<syntaxhighlight lang="ml/i">MCSKIP "WITH" NL
+"" Arithmetic/Integer
+"" assumes macros on input stream 1, terminal on stream 2
+MCSKIP MT,<>
 MCINS %.
-MCDEF SL SPACES NL AS MCSET T1=%A1.
+MCDEF SL SPACES NL AS <MCSET T1=%A1.
 MCSET T2=%A2.
- + b   = %%T1.+%T2..
- - b   = %%T1.-%T2..
- * b   = %%T1.*%T2..
-  b   = %%T1.%T2..
-  b = %%T1.-%%%T1.%T2..*%T2...
-D  uc    
-   c  c u. R c
-  f  c , f   ff.
+a + b   = %%T1.+%T2..
+a - b   = %%T1.-%T2..
+a * b   = %%T1.*%T2..
+a / b   = %%T1./%T2..
+a rem b = %%T1.-%%%T1./%T2..*%T2...
+Division is truncated to the greatest integer
+that does not exceed the exact result. Remainder matches
+the sign of the second operand, if the signs differ.

data/zettacode.files/arithmetic.integer/modula-2.txt

@@ -1,31 +1,31 @@
-MODULE 
+MODULE ints;
 
-IMPORT  IOu
+IMPORT  InOut;
 
-VAR     , b    : INTEGER
+VAR     a, b    : INTEGER;
 
 BEGIN
-  IOu.WS ("E   ub : ")   IOu.WBf
-  IOu.RI ()
-  IOu.RI (b)
-  IOu.WS (" + b   = ")  IOu.WI ( + b, 9)    IOu.WL
-  IOu.WS (" - b   = ")  IOu.WI ( - b, 9)    IOu.WL
-  IOu.WS (" * b   = ")  IOu.WI ( * b, 9)    IOu.WL
-  IOu.WS ("  b   = ")  IOu.WI ( DIV b, 9)  IOu.WL
-  IOu.WS (" MOD b = ")  IOu.WI ( MOD b, 9)  IOu.WL
-  IOu.WL
-END .Puc:$$ 
-E   ub : 12 7
- + b   =        19
- - b   =         5
- * b   =        84
-  b   =         1
- MOD b =         5
+  InOut.WriteString ("Enter two integer numbers : ");   InOut.WriteBf;
+  InOut.ReadInt (a);
+  InOut.ReadInt (b);
+  InOut.WriteString ("a + b   = ");  InOut.WriteInt (a + b, 9);    InOut.WriteLn;
+  InOut.WriteString ("a - b   = ");  InOut.WriteInt (a - b, 9);    InOut.WriteLn;
+  InOut.WriteString ("a * b   = ");  InOut.WriteInt (a * b, 9);    InOut.WriteLn;
+  InOut.WriteString ("a / b   = ");  InOut.WriteInt (a DIV b, 9);  InOut.WriteLn;
+  InOut.WriteString ("a MOD b = ");  InOut.WriteInt (a MOD b, 9);  InOut.WriteLn;
+  InOut.WriteLn;
+END ints.Producing:$$ ints
+Enter two integer numbers : 12 7
+a + b   =        19
+a - b   =         5
+a * b   =        84
+a / b   =         1
+a MOD b =         5
 
-$$ 
-E   ub : 123 -111
- + b   =        12
- - b   =       234
- * b   =    -13653
-  b   =        -1
- MOD b =        12
+$$ ints
+Enter two integer numbers : 123 -111
+a + b   =        12
+a - b   =       234
+a * b   =    -13653
+a / b   =        -1
+a MOD b =        12

data/zettacode.files/arithmetic.integer/modula-3.txt

@@ -1,15 +1,15 @@
-MODULE A EXPORTS M
+MODULE Arith EXPORTS Main;
 
-IMPORT IO, F
+IMPORT IO, Fmt;
 
-VAR , b: INTEGER
+VAR a, b: INTEGER;
 
 BEGIN
-   := IO.GI()
-  b := IO.GI()
-  IO.Pu("+b = "  F.I( + b)  "\")
-  IO.Pu("-b = "  F.I( - b)  "\")
-  IO.Pu("*b = "  F.I( * b)  "\")
-  IO.Pu(" DIV b = "  F.I( DIV b)  "\")
-  IO.Pu(" MOD b = "  F.I( MOD b)  "\")
-END A.
+  a := IO.GetInt();
+  b := IO.GetInt();
+  IO.Put("a+b = " & Fmt.Int(a + b) & "\n");
+  IO.Put("a-b = " & Fmt.Int(a - b) & "\n");
+  IO.Put("a*b = " & Fmt.Int(a * b) & "\n");
+  IO.Put("a DIV b = " & Fmt.Int(a DIV b) & "\n");
+  IO.Put("a MOD b = " & Fmt.Int(a MOD b) & "\n");
+END Arith.

data/zettacode.files/arithmetic.integer/mumps.txt

@@ -1,52 +1,52 @@
-N: M[UMPS]    c "u".
-W b    ub, "u"   u      ""
-,     ffc.
+<p>Note: M[UMPS] has an operator called "modulo".
+When both operands are positive numbers, "modulo" has a result that looks a lot like "remainder";
+however, there is an important difference.</p>
 
-T b u  cc f "u"    
-ff f "",  D Ku' f (Vu 1 f  "b b"), 
-f u  bu f ccc b  fu b N H Ab (Auu 5, 1802 – A 6, 1829).
+<p>To better understand the intricacies of "modulo" and how it is
+different from "remainder", see Donald Knuth's definition (Volume 1 of the "big books"), or
+find out the beauty of cyclic algebra as formulated by Niels Henrik Abel (August 5, 1802 – April 6, 1829).</p>
 
-A(f,cod)	 Mmc oo
-	W "Pu",?12,f,"+",c,?25," = ",f+c,!
-	W "Mu",?12,f,"-",c,?25," = ",f-c,!
-	W "Mu",?12,f,"*",c,?25," = ",f*c,!
-	W "D",?12,f,"",c,?25," = ",fc,!
-	W "I D",?12,f,"\",c,?25," = ",f\c,!
-	W "P",?12,f,"**",c,?25," = ",f**c,!
-	W "Mu",?12,f,"#",c,?25," = ",f#c,!
-	W "A",?12,f,"",c,?25," = ",fc,!
-	W "O",?12,f,"!",c,?25," = ",f!c,!
-	Qu
+Arith(first,second)	; Mathematical operators
+	Write "Plus",?12,first,"+",second,?25," = ",first+second,!
+	Write "Minus",?12,first,"-",second,?25," = ",first-second,!
+	Write "Multiply",?12,first,"*",second,?25," = ",first*second,!
+	Write "Divide",?12,first,"/",second,?25," = ",first/second,!
+	Write "Int Divide",?12,first,"\",second,?25," = ",first\second,!
+	Write "Power",?12,first,"**",second,?25," = ",first**second,!
+	Write "Modulo",?12,first,"#",second,?25," = ",first#second,!
+	Write "And",?12,first,"&amp;",second,?25," = ",first&amp;second,!
+	Write "Or",?12,first,"!",second,?25," = ",first!second,!
+	Quit
 
-D A(2,3)
-Pu        2+3           = 5
-Mu       2-3           = -1
-Mu    2*3           = 6
-D      23           = .6666666666666666667
-I D  2\3           = 0
-P       2**3          = 8
-Mu      2#3           = 2
-A         23           = 1
-O          2!3           = 1
+Do Arith(2,3)
+Plus        2+3           = 5
+Minus       2-3           = -1
+Multiply    2*3           = 6
+Divide      2/3           = .6666666666666666667
+Int Divide  2\3           = 0
+Power       2**3          = 8
+Modulo      2#3           = 2
+And         2&amp;3           = 1
+Or          2!3           = 1
  
-D A(16,0.5)
-Pu        16+.5         = 16.5
-Mu       16-.5         = 15.5
-Mu    16*.5         = 8
-D      16.5         = 32
-I D  16\.5         = 32
-P       16**.5        = 4
-Mu      16#.5         = 0
-A         16.5         = 1
-O          16!.5         = 1
+Do Arith(16,0.5)
+Plus        16+.5         = 16.5
+Minus       16-.5         = 15.5
+Multiply    16*.5         = 8
+Divide      16/.5         = 32
+Int Divide  16\.5         = 32
+Power       16**.5        = 4
+Modulo      16#.5         = 0
+And         16&amp;.5         = 1
+Or          16!.5         = 1
  
-D A(0,2)
-Pu        0+2           = 2
-Mu       0-2           = -2
-Mu    0*2           = 0
-D      02           = 0
-I D  0\2           = 0
-P       0**2          = 0
-Mu      0#2           = 0
-A         02           = 0
-O          0!2           = 1
+Do Arith(0,2)
+Plus        0+2           = 2
+Minus       0-2           = -2
+Multiply    0*2           = 0
+Divide      0/2           = 0
+Int Divide  0\2           = 0
+Power       0**2          = 0
+Modulo      0#2           = 0
+And         0&amp;2           = 0
+Or          0!2           = 1

data/zettacode.files/arithmetic.integer/nanoquery.txt

@@ -1,13 +1,13 @@
-{{|P}}
- "Numb 1: "
- = (u())
- "Nub 2: "
- = (u())
+{{trans|Python}}
+print "Number 1: "
+x = int(input())
+print "Number 2: "
+y = int(input())
 
- f("Su: %",  + )
- f("Dffc: %",  - )
- f("Puc: %",  * )
- f("Qu: %f",   )
+println format("Sum: %d", x + y)
+println format("Difference: %d", x - y)
+println format("Product: %d", x * y)
+println format("Quotient: %f", x / y)
 
- f("R: %",  % )
- f("P: %",  ^ )
+println format("Remainder: %d", x % y)
+println format("Power: %d", x ^ y)

data/zettacode.files/arithmetic.integer/nemerle.txt

@@ -1,18 +1,18 @@
-A  b f C# u b. N  I' u    (**), bu M.P()  u   C# u u  .
-u Sm
+Adapted nearly verbatim from C# solution above. Note that I've used the exponentiation operator (**), but Math.Pow() as used in the C# solution would also work.
+using System;
  
-c P
+class Program
 {
-    c M( : []) : 
+    static Main(args : array[string]) : void
     {
-        f  = C.TI32([0])
-        f b = C.TI32([1])
+        def a = Convert.ToInt32(args[0]);
+        def b = Convert.ToInt32(args[1]);
  
-        C.WL("{0} + {1} = {2}", , b,  + b)
-        C.WL("{0} - {1} = {2}", , b,  - b)
-        C.WL("{0} * {1} = {2}", , b,  * b)
-        C.WL("{0}  {1} = {2}", , b,   b)  uc  0
-        C.WL("{0} % {1} = {2}", , b,  % b)  c  f f 
-        C.WL("{0} ** {1} = {2}", , b,  ** b)
+        Console.WriteLine("{0} + {1} = {2}", a, b, a + b);
+        Console.WriteLine("{0} - {1} = {2}", a, b, a - b);
+        Console.WriteLine("{0} * {1} = {2}", a, b, a * b);
+        Console.WriteLine("{0} / {1} = {2}", a, b, a / b); // truncates towards 0
+        Console.WriteLine("{0} % {1} = {2}", a, b, a % b); // matches sign of first operand
+        Console.WriteLine("{0} ** {1} = {2}", a, b, a ** b);
     }
 }

data/zettacode.files/arithmetic.integer/netrexx.txt

@@ -1,14 +1,14 @@
-{{|REXX}}
-* NR *
+{{trans|REXX}}
+/* NetRexx */
 
- c f c j cf b b
+options replace format comments java crossref symbols binary
 
- " 2  u  b b"
-   b
-  "+" b "="  + b
-  "-" b "="  - b
-  "*" b "="  * b
-  "" b "="  % b ""   b "( f f )"
-  "^" b "="  ** b
+say "enter 2 integer values separated by blanks"
+parse ask a b
+say a "+" b "=" a + b
+say a "-" b "=" a - b
+say a "*" b "=" a * b
+say a "/" b "=" a % b "remaining" a // b "(sign from first operand)"
+say a "^" b "=" a ** b
 
-u
+return

data/zettacode.files/arithmetic.integer/newlisp.txt

@@ -1,26 +1,26 @@
 
- .
- f 2012-01-17
+; integer.lsp
+; oofoe 2012-01-17
 
-(f ( ) ( ) ( (-)))
-(q  ( "P       []: "))
-(q  ( "P                 : "))
+(define (aski msg) (print msg) (int (read-line)))
+(setq x (aski "Please type in an integer and press [enter]: "))
+(setq y (aski "Please type in another integer             : "))
 
- N  +, -, *,   %    .
-()
-( "Su: " (+  ))
-( "Dffc: " (-  ))
-( "Puc: " (*  ))
-( "I qu (u  0): " (  ))
-( "R: " (q  (%  )))
+; Note that +, -, *, / and % are all integer operations.
+(println)
+(println "Sum: " (+ x y))
+(println "Difference: " (- x y))
+(println "Product: " (* x y))
+(println "Integer quotient (rounds to 0): " (/ x y))
+(println "Remainder: " (setq r (% x y)))
 
-( "R  c: "
-	 (c ((= ( ) ( ) ( )) "b")
-	       ((= ( ) ( ))         "f")
-	       ((= ( ) ( ))         "c")))
+(println "Remainder sign matches: "
+	 (cond ((= (sgn r) (sgn x) (sgn y)) "both")
+	       ((= (sgn r) (sgn x))         "first")
+	       ((= (sgn r) (sgn y))         "second")))
 	 
-()
-( "E: " (  ))
+(println)
+(println "Exponentiation: " (pow x y))
 
-()  NL     f u c.
+(exit) ; NewLisp normally goes to listener after running script.
 

data/zettacode.files/arithmetic.integer/nial.txt

@@ -1,23 +1,23 @@
 
-E   Q'N7.
+Example tested with Q'Nial7.
 
-Df   u   f :
-     mc  OP A B{[f,,+,-,*,quo,mod,ow] A B}
+Define new operator using an atlas of operators:
+     arithmetic is OP A B{[first,last,+,-,*,quotient,mod,power] A B}
 
-T  :
-     -23 mc 7
+Test new operator:
+     -23 arithmetic 7
 -23 7 -16 -30 -161 -4 5 -3404825447
 
-N    cc f  qu cquc   cc,   b c  u       c? c.
+Negative divisors are not accepted for integer quotient <code>quotient</code> or remainder <code>mod</code>, and in both cases the result is an error with the message <code>?negative divisor</code>.
 
-F cquc, f   cBc  z,  u  z.
+For <code>quotient</code>, if the divisor <code>B</code> is zero, the result is zero.
 
-F cc, f   cBc  z,  u  cAc.
+For <code>mod</code>, if the divisor <code>B</code> is zero, the result is <code>A</code>.
 
-T qu   b    cBc         f    cAc.
+The quotient on division by a positive integer <code>B</code> is always an integer on the same side of the origin as <code>A</code>.
 
-N f f cquc:
+Nial definition of <code>quotient</code>:
 
-A quo B =f=  foo (A  B)
+A quotient B =f=  floor (A / B)
 
-cfc u   f (  ).
+<code>floor</code> rounds towards negative infinity (next lower integer).

data/zettacode.files/arithmetic.integer/nim.txt

@@ -1,25 +1,25 @@
-mo o, u
+import parseopt, strutils
  
+var 
+  opt: OptParser = initOptParser()
+  str = opt.cmdLineRest.split
+  a: int = 0
+  b: int = 0
  
-  : OP = OP()
-   = .cLR.
-  :  = 0
-  b:  = 0
+try:
+  a = parseInt(str[0])
+  b = parseInt(str[1])
+except ValueError:
+  quit("Invalid params. Two integers are expected.")
  
-:
-   = I([0])
-  b = I([1])
-c VuE:
-  qu("I . T   c.")
  
- 
-c("      : "  $)
-c("b      : "  $b)
-c(" + b  : "  $(+b))
-c(" - b  : "  $(-b))
-c(" * b  : "  $(*b))
-c("  b: "  $(  b)) #  u  z
-c("  b: "  $(  b)) # (  b)==() f ()!=(b)
-c(" ^ b  : "  $( ^ b))
+echo("a      : " & $a)
+echo("b      : " & $b)
+echo("a + b  : " & $(a+b))
+echo("a - b  : " & $(a-b))
+echo("a * b  : " & $(a*b))
+echo("a div b: " & $(a div b)) # div rounds towards zero
+echo("a mod b: " & $(a mod b)) # sign(a mod b)==sign(a) if sign(a)!=sign(b)
+echo("a ^ b  : " & $(a ^ b))
 
-Ecu: A 4 5
+Execute: Aritmint 4 5

data/zettacode.files/arithmetic.integer/nsis.txt

@@ -1,25 +1,25 @@
-A Ac  NSIS   b  [:.ucf.DcC4.#4.9.10.2 IO] uc.  I  b  c f     u u ( f  ),  I  b  -c u u  u u,    f    u-u c.
-Fuco Amc
-	Pu $0
-	Pu $1
-	Pu $2
-	SC $0 21
-	SC $1 -2
+All Arithmetic in NSIS is handled by the [http://nsis.sourceforge.net/Docs/Chapter4.html#4.9.10.2 IntOp] instruction.  It is beyond the scope of this task to implement user input (a fairly involved task), so I will be providing hard-coded values simulating the user input, with the intention of later adding the user-input piece.
+Function Arithmetic
+	Push $0
+	Push $1
+	Push $2
+	StrCpy $0 21
+	StrCpy $1 -2
 	
-	IO $2 $0 + $1
-	DP "$0 + $1 = $2"
-	IO $2 $0 - $1
-	DP "$0 - $1 = $2"
-	IO $2 $0 * $1
-	DP "$0 * $1 = $2"
-	IO $2 $0  $1
-	DP "$0  $1 = $2"
-	DP "Ru    f"
-	IO $2 $0 % $1
-	DP "$0 % $1 = $2"
-	DP "S f  c  f ub"
+	IntOp $2 $0 + $1
+	DetailPrint "$0 + $1 = $2"
+	IntOp $2 $0 - $1
+	DetailPrint "$0 - $1 = $2"
+	IntOp $2 $0 * $1
+	DetailPrint "$0 * $1 = $2"
+	IntOp $2 $0 / $1
+	DetailPrint "$0 / $1 = $2"
+	DetailPrint "Rounding is toward negative infinity"
+	IntOp $2 $0 % $1
+	DetailPrint "$0 % $1 = $2"
+	DetailPrint "Sign of remainder matches the first number"
 	
-	P $2
-	P $1
-	P $0
-FucE
+	Pop $2
+	Pop $1
+	Pop $0
+FunctionEnd