zettacode 0.1.3 → 0.1.4

data/files.zettacode2/arithmetic.integer/lasso.txt

@@ -0,0 +1,8 @@
+local(a = 6, b = 4)
+#a + #b // 10
+#a - #b // 2
+#a * #b // 24
+#a / #b // 1
+#a % #b // 2
+math_pow(#a,#b) // 1296
+math_pow(#b,#a) // 4096

data/files.zettacode2/arithmetic.integer/lfe.txt

@@ -0,0 +1,32 @@
+
+
+(defmodule arith
+  (export all))
+
+(defun demo-arith ()
+  (case (: io fread '"Please enter two integers: " '"~d~d")
+    ((tuple 'ok (a b))
+      (: io format '"~p + ~p = ~p~n" (list a b (+ a b)))
+      (: io format '"~p - ~p = ~p~n" (list a b (- a b)))
+      (: io format '"~p * ~p = ~p~n" (list a b (* a b)))
+      (: io format '"~p^~p = ~p~n" (list a b (: math pow a b)))
+      ; div truncates towards zero
+      (: io format '"~p div ~p = ~p~n" (list a b (div a b)))
+      ; rem's result takes the same sign as the first operand
+      (: io format '"~p rem ~p = ~p~n" (list a b (rem a b))))))
+
+
+Usage from the LFE REPL:
+
+> (slurp '"arith.lfe")
+#(ok arith)
+> (demo-arith)
+Please enter two integers: 2 8
+2 + 8 = 10
+2 - 8 = -6
+2 * 8 = 16
+2^8 = 256.0
+2 div 8 = 0
+2 rem 8 = 2
+ok
+

data/files.zettacode2/arithmetic.integer/liberty_basic.txt

@@ -0,0 +1,12 @@
+Note that raising to a power can display very large integers without going to approximate power-of-ten notation.
+
+input "Enter the first integer:  "; first
+input "Enter the second integer: "; second
+
+print "The sum is " ; first + second
+print "The difference is " ; first -second
+print "The product is " ; first *second
+if second <>0 then print "The integer quotient is " ; int( first /second); " (rounds towards 0)" else print "Division by zero not allowed."
+print "The remainder is " ; first MOD second; " (sign matches first operand)"
+print "The first raised to the power of the second is " ; first ^second
+

data/files.zettacode2/arithmetic.integer/lil.txt

@@ -0,0 +1,14 @@
+# Arithmetic/Integer, in LIL
+write "Enter two numbers separated by space: "
+if {[canread]} {set line [readline]}
+print
+
+set a [index $line 0]
+set b [index $line 1]
+print "A is $a"", B is $b"
+print "Sum               A + B is [expr $a + $b]"
+print "Difference        A - B is [expr $a - $b]"
+print "Product           A * B is [expr $a * $b]"
+print "Integer Quotient  A \\ B is [expr $a \ $b], truncates toward zero"
+print "Remainder         A % B is [expr $a % $b], sign follows first operand"
+print "LIL has no exponentiation expression operator"

data/files.zettacode2/arithmetic.integer/lingo.txt

@@ -0,0 +1,10 @@
+-- X, Y: 2 editable field members, shown as sprites in the current GUI
+x = integer(member("X").text)
+y = integer(member("Y").text)
+
+put "Sum: "       , x + y
+put "Difference: ", x - y
+put "Product: "   , x * y
+put "Quotient: "  , x / y   -- Truncated towards zero
+put "Remainder: " , x mod y -- Result has sign of left operand
+put "Exponent: "  , power(x, y)

data/files.zettacode2/arithmetic.integer/little.txt

@@ -0,0 +1,15 @@
+# Maybe you need to import the mathematical funcions 
+# from Tcl with:
+# eval("namespace path ::tcl::mathfunc");
+
+void main() {
+    int a, b; 
+    puts("Enter two integers:");
+    a = (int)(gets(stdin)); 
+    b = (int)(gets(stdin)); 
+    puts("${a} + ${b} = ${a+b}");
+    puts("${a} - ${b} = ${a-b}");
+    puts("${a} * ${b} = ${a*b}");
+    puts("${a} / ${b} = ${a/b}, remainder ${a%b}");
+    puts("${a} to the power of ${b} = ${(int)pow(a,b)}");
+}

data/files.zettacode2/arithmetic.integer/livecode.txt

@@ -0,0 +1,17 @@
+ask "enter 2 numbers (comma separated)"
+if it is not empty then
+    put item 1 of it into n1
+    put item 2 of it into n2
+    put sum(n1,n2) into ai["sum"]
+    put n1 * n2 into ai["product"]
+    put n1 div n2 into ai["quotient"]  -- truncates
+    put n1 mod n2 into ai["remainder"]
+    put n1^n2 into ai["power"]
+    combine ai using comma and colon
+    put ai
+end if
+Examples-2,4  - power:16,product:-8,quotient:0,remainder:-2,sum:2
+2,-4  - power:0.0625,product:-8,quotient:0,remainder:2,sum:-2
+-2,-4 - power:0.0625,product:8,quotient:0,remainder:-2,sum:-6
+2,4   - power:16,product:8,quotient:0,remainder:2,sum:6
+11,4  - power:14641,product:44,quotient:2,remainder:3,sum:15

data/files.zettacode2/arithmetic.integer/logo.txt

@@ -0,0 +1,11 @@
+to operate :a :b
+  (print [a =] :a)
+  (print [b =] :b)
+  (print [a + b =] :a + :b)
+  (print [a - b =] :a - :b)
+  (print [a * b =] :a * :b)
+  (print [a / b =] int :a / :b)
+  (print [a mod b =] modulo :a :b)
+end
+
+Each infix operator also has a prefix synonym (sum, difference, product, quotient). Sum and product can also have arity greater than two when used in parentheses (sum 1 2 3). Infix operators in general have high precedence; you may need to enclose their arguments in parentheses to obtain the correct expression.

data/files.zettacode2/arithmetic.integer/lse64.txt

@@ -0,0 +1,10 @@
+over : 2 pick
+2dup : over over
+
+arithmetic : \
+  " A=" ,t over , sp " B=" ,t dup , nl \
+  " A+B=" ,t 2dup + , nl \
+  " A-B=" ,t 2dup - , nl \
+  " A*B=" ,t 2dup * , nl \
+  " A/B=" ,t 2dup / , nl \
+  " A%B=" ,t      % , nl

data/files.zettacode2/arithmetic.integer/lua.txt

@@ -0,0 +1,9 @@
+local x = io.read()
+local y = io.read()
+
+print ("Sum: "       , (x + y))
+print ("Difference: ", (x - y))
+print ("Product: "   , (x * y))
+print ("Quotient: "  , (x / y)) -- Does not truncate
+print ("Remainder: " , (x % y)) -- Result has sign of right operand
+print ("Exponent: "  , (x ^ y))

data/files.zettacode2/arithmetic.integer/m2000_interpreter.txt

@@ -0,0 +1,54 @@
+We can  use variables with %, which are double inside with no decimal part. These can have 17 digits. Also A%=1.5 make it 2, not 1. This has a tricky situation: A%=1/2 give 1 to A%. We can use FLOOR() or INT() is the same, or CEIL(), and there is a BANK() which is a Banker Round: BANK(2.5)=2 and BANK(3.5)=4.
+
+
+
+
+<syntaxhighlight lang="m2000 interpreter">
+MODULE LikeCommodoreBasic {
+      \\ ADDITION: EUCLIDEAN DIV# &amp; MOD# AND ** FOR POWER INCLUDING ^
+      10 INPUT "ENTER A NUMBER:"; A%
+      20 INPUT "ENTER ANOTHER NUMBER:"; B%
+      30 PRINT "ADDITION:";A%;"+";B%;"=";A%+B%
+      40 PRINT "SUBTRACTION:";A%;"-";B%;"=";A%-B%
+      50 PRINT "MULTIPLICATION:";A%;"*";B%;"=";A%*B%
+      60 PRINT "INTEGER DIVISION:";A%;"DIV";B%;"=";A% DIV B%
+      65 PRINT "INTEGER EUCLIDEAN DIVISION:";A%;"DIV";B%;"=";A% DIV# B%
+      70 PRINT "REMAINDER OR MODULO:";A%;"MOD";B%;"=";A% MOD B%
+      75 PRINT "EUCLIDEAN REMAINDER OR MODULO:";A%;"MOD#";B%;"=";A% MOD# B%
+      80 PRINT "POWER:";A%;"^";B%;"=";A%^B%
+      90 PRINT "POWER:";A%;"**";B%;"=";A%**B%
+}
+LikeCommodoreBasic
+
+
+Module IntegerTypes {
+      a=12% ' Integer 16 bit
+      b=12&amp; ' Long 32 bit
+      c=12@' Decimal (29 digits)
+      Def ExpType$(x)=Type$(x)
+      Print ExpType$(a+1)="Double"
+      Print ExpType$(a+1%)="Integer"
+      Print ExpType$(a div 5)="Double"
+      Print ExpType$(a div 5%)="Double"
+      Print ExpType$(a mod 5)="Double"
+      Print ExpType$(a mod 5%)="Double"
+      Print ExpType$(a**2)="Double"
+      
+      Print ExpType$(b+1)="Double"
+      Print ExpType$(b+1&amp;)="Long"
+      Print ExpType$(b div 5)="Double"
+      Print ExpType$(b div 5&amp;)="Double"
+      Print ExpType$(b mod 5)="Double"
+      Print ExpType$(b mod 5&amp;)="Double"
+      Print ExpType$(b**2)="Double"
+
+      Print ExpType$(c+1)="Decimal"
+      Print ExpType$(c+1@)="Decimal"
+      Print ExpType$(c div 5)="Decimal"
+      Print ExpType$(c div 5@)="Decimal"
+      Print ExpType$(c mod 5)="Decimal"
+      Print ExpType$(c mod 5@)="Decimal"     
+      Print ExpType$(c**2)="Double"
+}
+IntegerTypes
+

data/files.zettacode2/arithmetic.integer/m4.txt

@@ -0,0 +1,17 @@
+
+Because of the particular nature of M4, the only user-input is the code itself. Anyway the following code can be used:
+eval(A+B)
+eval(A-B)
+eval(A*B)
+eval(A/B)
+eval(A%B)
+
+once saved in a file, e.g. <tt>operations.m4</tt>:
+
+m4 -DA=4 -DB=6 operations.m4
+
+or using a sort of ''driver'':
+
+define(`A', 4)dnl
+define(`B', 6)dnl
+include(`operations.m4')

data/files.zettacode2/arithmetic.integer/maple.txt

@@ -0,0 +1,25 @@
+These operations are all built-in.  As all operations are exact, there are no rounding issues involved.
+
+DoIt := proc()
+        local a := readstat( "Input an integer: " ):
+        local b := readstat( "Input another integer: " ):
+        printf( "Sum = %d\n",  a + b ):
+        printf( "Difference = %d\n",  a - b ):
+        printf( "Product = %d\n",  a * b ):
+        printf( "Quotient = %d\n",  iquo( a, b, 'c' ) ):
+        printf( "Remainder = %d\n", c ); # or irem( a, b )
+        NULL # quiet return
+end proc:
+
+Here is an example of calling DoIt.
+
+> DoIt();
+Input an integer: 15;
+Input another integer: 12;
+Sum = 27
+Difference = 3
+Product = 180
+Quotient = 1
+Remainder = 3
+>
+

data/files.zettacode2/arithmetic.integer/mathcad.txt

@@ -0,0 +1,51 @@
+The text below (from "Task Notes" onwards) is pretty well what you will see on a Mathcad worksheet across most versions (eg, Mathcad 15, Mathcad Prime 6.0, and Mathcad Prime 6.0 Express).   Mathcad's "whiteboard" interface allows the user to mix formatted text regions with formatted math regions.  Text region formatting is fairly arbitrary, individual characters can have their font, font size and bold/italic/underline settings set or changed at will.  Math regions use amendable styles to identify variables, functions (normally built-in functions), keywords, system words and units (Mathcad has a units-aware, SI-based quantity system).  It really is a simple as 'writing' on the whiteboard.
+
+----
+
+'''Task Notes'''
+
+''For quotient, indicate how it rounds (e.g. towards zero, towards negative infinity, etc.).''
+
+There is no quotient function in Mathcad, only complex division.  We emulate quotient by standard division followed by rounding using both floor, which rounds towards negative infinity, and trunc, which rounds towards zero.
+
+''For remainder, indicate whether its sign matches the sign of the first operand or of the second operand, if they are different.
+''
+We use the Mathcad function mod(x,y), which returns x modulo y, and has the same sign as x. 
+
+'''Instructions'''
+
+Enter two integers of your choice for Int1 and Int2.
+
+(type into the right hand side of the 'Int1:= ' and 'Int2:=' statements, overwriting or modifying any numbers already there)
+
+'''Implementation'''
+
+'''Mathcad Input and Output'''
+
+Mathcad "standard" input and output takes place directly on a worksheet ("program source code"). 
+
+'''Inputs''':
+
+== ''the user types in values after := (definition) operator''
+
+Integer One:  ''Int1'':='''-8'''
+
+Integer Two:  ''Int2'':='''3'''
+
+'''Results''':
+
+== ''Mathcad automatically calculates and displays results after = (evaluation) operator.''
+
+sum              :  ''Int1'' + ''Int2'' = -5  
+
+difference       :  ''Int1'' - ''Int2'' = -11
+
+product          :  ''Int1'' · ''Int2'' = -24
+
+integer quotient :  floor(''Int1''÷''Int2'')=-3     trunc(Int1÷Int2)=-2  
+
+remainder        :  mod(''Int1'',''Int2'')=-2
+
+exponentiation   :  ''Int1''<sup>''Int2''</sup>=-512
+
+----

data/files.zettacode2/arithmetic.integer/mathematica}}-{{header|wolfram_language.txt

@@ -0,0 +1,18 @@
+Mathematica has all the function built-in to handle this task. Example:
+a = Input["Give me an integer please!"];
+b = Input["Give me another integer please!"];
+Print["You gave me ", a, " and ", b];
+Print["sum: ", a + b];
+Print["difference: ", a - b];
+Print["product: ", a b];
+Print["integer quotient: ", Quotient[a, b]];
+Print["remainder: ", Mod[a, b]];
+Print["exponentiation: ", a^b];
+gives back for input 17 and 3:
+You gave me 17 and 3
+sum: 20
+difference: 14
+product: 51
+integer quotient: 5
+remainder: 2
+exponentiation: 4913

data/files.zettacode2/arithmetic.integer/matlab}}_-_{{header|octave.txt

@@ -0,0 +1,8 @@
+disp("integer a: "); a = scanf("%d", 1);
+disp("integer b: "); b = scanf("%d", 1);
+a+b
+a-b
+a*b
+floor(a/b)
+mod(a,b)
+a^b

data/files.zettacode2/arithmetic.integer/maxima.txt

@@ -0,0 +1,10 @@
+block(
+   [a: read("a"), b: read("b")],
+   print(a + b),
+   print(a - b),
+   print(a * b),
+   print(a / b),
+   print(quotient(a, b)),
+   print(remainder(a, b)),
+   a^b
+);

data/files.zettacode2/arithmetic.integer/maxscript.txt

@@ -0,0 +1,8 @@
+x = getKBValue prompt:"First number"
+y = getKBValue prompt:"Second number:"
+
+format "Sum: %\n" (x + y) 
+format "Difference: %\n" (x - y) 
+format "Product: %\n" (x * y) 
+format "Quotient: %\n" (x / y) 
+format "Remainder: %\n" (mod x y)

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

@@ -0,0 +1,44 @@
+
+:- 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.
+        %
+        io.format("A / B = %d\n", [i(A / B)], !IO),
+
+        % Division: round towards minus infinity.
+        %
+        io.format("A div B = %d\n", [i(A div B)], !IO), 
+    
+        % Modulus: X mod Y = X - (X div Y) * Y.
+        %
+        io.format("A mod B = %d\n", [i(A mod B)], !IO),
+
+        % Remainder: X rem Y = X - (X / Y) * Y.
+        %
+        io.format("A rem B = %d\n", [i(A rem B)], !IO),
+
+        % Exponentiation is done using the function int.pow/2.
+        %
+        io.format("A `pow` B = %d\n", [i(A `pow` B)], !IO)
+      else
+        io.set_exit_status(1, !IO)
+    ).
+

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

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

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

@@ -0,0 +1,5 @@
+{{works with|min|0.19.3}}
+(concat dup -> ' prepend "$1 -> $2" swap % puts!) :show
+
+("Enter an integer" ask int) 2 times ' prepend
+('+ '- '* 'div 'mod) quote-map ('show concat) map cleave

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

@@ -0,0 +1,18 @@
+ML/I will read two integers from 'standard input' or similar, 
+and then output the results to 'standard output' or similar.
+
+<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.
+MCSET T2=%A2.
+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/files.zettacode2/arithmetic.integer/modula-2.txt

@@ -0,0 +1,31 @@
+MODULE ints;
+
+IMPORT  InOut;
+
+VAR     a, b    : INTEGER;
+
+BEGIN
+  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
+
+$$ ints
+Enter two integer numbers : 123 -111
+a + b   =        12
+a - b   =       234
+a * b   =    -13653
+a / b   =        -1
+a MOD b =        12

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

@@ -0,0 +1,15 @@
+MODULE Arith EXPORTS Main;
+
+IMPORT IO, Fmt;
+
+VAR a, b: INTEGER;
+
+BEGIN
+  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/files.zettacode2/arithmetic.integer/mumps.txt

@@ -0,0 +1,52 @@
+<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>
+
+<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>
+
+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
+
+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
+ 
+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
+ 
+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/files.zettacode2/arithmetic.integer/nanoquery.txt

@@ -0,0 +1,13 @@
+{{trans|Python}}
+print "Number 1: "
+x = int(input())
+print "Number 2: "
+y = int(input())
+
+println format("Sum: %d", x + y)
+println format("Difference: %d", x - y)
+println format("Product: %d", x * y)
+println format("Quotient: %f", x / y)
+
+println format("Remainder: %d", x % y)
+println format("Power: %d", x ^ y)

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

@@ -0,0 +1,18 @@
+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;
+ 
+class Program
+{
+    static Main(args : array[string]) : void
+    {
+        def a = Convert.ToInt32(args[0]);
+        def b = Convert.ToInt32(args[1]);
+ 
+        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/files.zettacode2/arithmetic.integer/netrexx.txt

@@ -0,0 +1,14 @@
+{{trans|REXX}}
+/* NetRexx */
+
+options replace format comments java crossref symbols binary
+
+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
+
+return

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

@@ -0,0 +1,26 @@
+
+; integer.lsp
+; oofoe 2012-01-17
+
+(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             : "))
+
+; 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)))
+
+(println "Remainder sign matches: "
+	 (cond ((= (sgn r) (sgn x) (sgn y)) "both")
+	       ((= (sgn r) (sgn x))         "first")
+	       ((= (sgn r) (sgn y))         "second")))
+	 
+(println)
+(println "Exponentiation: " (pow x y))
+
+(exit) ; NewLisp normally goes to listener after running script.
+

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

@@ -0,0 +1,23 @@
+
+Example tested with Q'Nial7.
+
+Define new operator using an atlas of operators:
+     arithmetic is OP A B{[first,last,+,-,*,quotient,mod,power] A B}
+
+Test new operator:
+     -23 arithmetic 7
+-23 7 -16 -30 -161 -4 5 -3404825447
+
+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>.
+
+For <code>quotient</code>, if the divisor <code>B</code> is zero, the result is zero.
+
+For <code>mod</code>, if the divisor <code>B</code> is zero, the result is <code>A</code>.
+
+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>.
+
+Nial definition of <code>quotient</code>:
+
+A quotient B =f=  floor (A / B)
+
+<code>floor</code> rounds towards negative infinity (next lower integer).