zettacode 0.1.0 → 0.1.1

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

@@ -1,32 +1,32 @@
 
 
-(fu 
-  ( ))
-
-(fu - ()
-  (c (:  f '"P   : " '"~~")
-    ((u ' ( b))
-      (:  f '"~ + ~ = ~~" (  b (+  b)))
-      (:  f '"~ - ~ = ~~" (  b (-  b)))
-      (:  f '"~ * ~ = ~~" (  b (*  b)))
-      (:  f '"~^~ = ~~" (  b (:    b)))
-        uc  z
-      (:  f '"~  ~ = ~~" (  b (  b)))
-       ' u       f 
-      (:  f '"~  ~ = ~~" (  b (  b))))))
-
-
-U f  LFE REPL:
-
- (u '".f")
-#( )
- (-)
-P   : 2 8
+(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  8 = 0
-2  8 = 2
-
+2 div 8 = 0
+2 rem 8 = 2
+ok
 

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

@@ -1,12 +1,12 @@
-N      c     u    -f- .
+Note that raising to a power can display very large integers without going to approximate power-of-ten notation.
 
-u "E  f :  " f
-u "E  c : " c
+input "Enter the first integer:  "; first
+input "Enter the second integer: "; second
 
- "T u  "  f + c
- "T ffc  "  f -c
- "T uc  "  f *c
-f c 0   "T  qu  "  ( f c) " (u  0)"   "D b z  ."
- "T   "  f MOD c " ( c f )"
- "T f     f  c  "  f ^c
+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/zettacode.files/arithmetic.integer/lil.txt

@@ -1,14 +1,14 @@
-# AmcI,  LIL
- "E  ub  b c: "
-f {[c]} {  []}
+# Arithmetic/Integer, in LIL
+write "Enter two numbers separated by space: "
+if {[canread]} {set line [readline]}
+print
 
-
-  [ $ 0]
- b [ $ 1]
- "A  $"", B  $b"
- "Su               A + B  [ $ + $b]"
- "Dffc        A - B  [ $ - $b]"
- "Puc           A * B  [ $ * $b]"
- "I Qu  A \\ B  [ $ \ $b], uc  z"
- "R         A % B  [ $ % $b],  f f "
- "LIL     "
+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/zettacode.files/arithmetic.integer/lingo.txt

@@ -1,10 +1,10 @@
--- X, Y: 2 db fd mmb, ow     cu GUI
- = (b("X").)
- = (b("Y").)
+-- X, Y: 2 editable field members, shown as sprites in the current GUI
+x = integer(member("X").text)
+y = integer(member("Y").text)
 
-u "Su: "       ,  + 
-u "Dffc: ",  - 
-u "Puc: "   ,  * 
-u "Qu: "  ,      -- Tuc  z
-u "R: " ,    -- Ru   f f 
-u "E: "  , (, )
+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/zettacode.files/arithmetic.integer/little.txt

@@ -1,15 +1,15 @@
-# Mb ou d o mo  mmc fuco 
-# f Tc :
-# ("c  ::c::fuc")
+# Maybe you need to import the mathematical funcions 
+# from Tcl with:
+# eval("namespace path ::tcl::mathfunc");
 
- () {
-     , b 
-    u("E  :")
-     = ()(()) 
-    b = ()(()) 
-    u("${} + ${b} = ${+b}")
-    u("${} - ${b} = ${-b}")
-    u("${} * ${b} = ${*b}")
-    u("${}  ${b} = ${b},  ${%b}")
-    u("${}    f ${b} = ${()(,b)}")
+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/zettacode.files/arithmetic.integer/livecode.txt

@@ -1,17 +1,17 @@
-k " 2 umb (comm d)"
-f     
-    u  1 f   1
-    u  2 f   2
-    u u(1,2)  ["u"]
-    u 1 * 2  ["uc"]
-    u 1  2  ["qu"]  -- uc
-    u 1  2  [""]
-    u 1^2  [""]
-    cb  u c  c
-    u 
- f
-Em-2,4  - ow:16,oduc:-8,quo:0,md:-2,um:2
-2,-4  - :0.0625,uc:-8,qu:0,:2,u:-2
--2,-4 - :0.0625,uc:8,qu:0,:-2,u:-6
-2,4   - :16,uc:8,qu:0,:2,u:6
-11,4  - :14641,uc:44,qu:2,:3,u:15
+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/zettacode.files/arithmetic.integer/logo.txt

@@ -1,11 +1,11 @@
-o o : :b
-  ( [ =] :)
-  ( [b =] :b)
-  ( [ + b =] : + :b)
-  ( [ - b =] : - :b)
-  ( [ * b =] : * :b)
-  ( [  b =]  :  :b)
-  ( [  b =] u : :b)
+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
 
-
-Ec f     f  (u, ffc, uc, qu). Su  uc c        u   (u 1 2 3). If      cc u    c  u    b  cc .
+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/zettacode.files/arithmetic.integer/lse64.txt

@@ -1,10 +1,10 @@
-ov : 2 ck
-2u :  
+over : 2 pick
+2dup : over over
 
-c : \
-  " A=" ,  ,  " B=" , u ,  \
-  " A+B=" , 2u + ,  \
-  " A-B=" , 2u - ,  \
-  " A*B=" , 2u * ,  \
-  " AB=" , 2u  ,  \
-  " A%B=" ,      % , 
+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/zettacode.files/arithmetic.integer/lua.txt

@@ -1,9 +1,9 @@
-oc  = o.d()
-c  = .()
+local x = io.read()
+local y = io.read()
 
- ("Su: "       , ( + ))
- ("Dffc: ", ( - ))
- ("Puc: "   , ( * ))
- ("Qu: "  , (  )) -- D  uc
- ("R: " , ( % )) -- Ru   f  
- ("E: "  , ( ^ ))
+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/zettacode.files/arithmetic.integer/m2000_interpreter.txt

@@ -1,54 +1,54 @@
-W c  u b  %, c  ub    c . T c  17 . A A%=1.5   2,  1. T   c u: A%=12  1  A%. W c u FLOOR()  INT()   ,  CEIL(),     BANK() c   B Ru: BANK(2.5)=2  BANK(3.5)=4.
+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.
 
 
 
 
- ="2000 "
-MODULE LCBc {
-      \\ ADDITION: EUCLIDEAN DIV#  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%
+<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%
 }
-LCBc
-
-
-Mu IT {
-      =12% ' I 16 b
-      b=12 ' L 32 b
-      c=12@' Dc (29 )
-      Df ET$()=T$()
-      P ET$(+1)="Dub"
-      P ET$(+1%)="I"
-      P ET$(  5)="Dub"
-      P ET$(  5%)="Dub"
-      P ET$(  5)="Dub"
-      P ET$(  5%)="Dub"
-      P ET$(**2)="Dub"
+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"
       
-      P ET$(b+1)="Dub"
-      P ET$(b+1)="L"
-      P ET$(b  5)="Dub"
-      P ET$(b  5)="Dub"
-      P ET$(b  5)="Dub"
-      P ET$(b  5)="Dub"
-      P ET$(b**2)="Dub"
-
-      P ET$(c+1)="Dc"
-      P ET$(c+1@)="Dc"
-      P ET$(c  5)="Dc"
-      P ET$(c  5@)="Dc"
-      P ET$(c  5)="Dc"
-      P ET$(c  5@)="Dc"     
-      P ET$(c**2)="Dub"
+      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"
 }
-IT
+IntegerTypes
 

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

@@ -1,17 +1,17 @@
 
-Bcu f  cu u f M4,   u-u   c f. A  f c c b u:
-v(A+B)
-(A-B)
-(A*B)
-(AB)
-(A%B)
+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)
 
-c    f, .. .4:
+once saved in a file, e.g. <tt>operations.m4</tt>:
 
-4 -DA=4 -DB=6 .4
+m4 -DA=4 -DB=6 operations.m4
 
- u   f '''':
+or using a sort of ''driver'':
 
-df(`A', 4)d
-f(`B', 6)
-cu(`.4')
+define(`A', 4)dnl
+define(`B', 6)dnl
+include(`operations.m4')

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

@@ -1,25 +1,25 @@
-T    bu-.  A    c,    u u .
+These operations are all built-in.  As all operations are exact, there are no rounding issues involved.
 
-DI := c()
-        c  := ( "Iu  : " ):
-        c b := ( "Iu  : " ):
-        f( "Su = %\",   + b ):
-        f( "Dffc = %\",   - b ):
-        f( "Puc = %\",   * b ):
-        f( "Qu = %\",  qu( , b, 'c' ) ):
-        f( "R = %\", c ) #  ( , b )
-        NULL # qu u
- c:
+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:
 
-H    f c DI.
-
- DI()
-Iu  : 15
-Iu  : 12
-Su = 27
-Dffc = 3
-Puc = 180
-Qu = 1
-R = 3
+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/zettacode.files/arithmetic.integer/mathcad.txt

@@ -1,51 +1,51 @@
-T  b (f "T N" )     u     Mc  c   (, Mc 15, Mc P 6.0,  Mc P 6.0 E).   Mc' "b" fc   u   f    f  .  T  f  f b, u cc c   f, f z  bcu    c  .  M  u b   f b, fuc ( bu- fuc), ,    u (Mc   u-, SI-b qu ).  I      ''   b.
+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.
 
 ----
 
-'''T N'''
+'''Task Notes'''
 
-''F qu, c   u (..  z,   f, c.).''
+''For quotient, indicate how it rounds (e.g. towards zero, towards negative infinity, etc.).''
 
-T   qu fuc  Mc,  c .  W u qu b   f b u u b f, c u   f,  uc, c u  z.
+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.
 
-''F , c    c   f  f   f  c , f   ff.
+''For remainder, indicate whether its sign matches the sign of the first operand or of the second operand, if they are different.
 ''
-W u  Mc fuc (,), c u  u ,       . 
+We use the Mathcad function mod(x,y), which returns x modulo y, and has the same sign as x. 
 
-'''Iuc'''
+'''Instructions'''
 
-E   f u cc f I1  I2.
+Enter two integers of your choice for Int1 and Int2.
 
-(      f  'I1:= '  'I2:=' ,   f  ub  )
+(type into the right hand side of the 'Int1:= ' and 'Int2:=' statements, overwriting or modifying any numbers already there)
 
-'''I'''
+'''Implementation'''
 
-'''Mc Iu  Ouu'''
+'''Mathcad Input and Output'''
 
-Mc "" u  uu  c c    (" uc c"). 
+Mathcad "standard" input and output takes place directly on a worksheet ("program source code"). 
 
-'''Iu''':
+'''Inputs''':
 
-== '' u   u f := (f) ''
+== ''the user types in values after := (definition) operator''
 
-I O:  ''I1'':='''-8'''
+Integer One:  ''Int1'':='''-8'''
 
-I T:  ''I2'':='''3'''
+Integer Two:  ''Int2'':='''3'''
 
-'''Ru''':
+'''Results''':
 
-== ''Mc uc ccu   u f = (u) .''
+== ''Mathcad automatically calculates and displays results after = (evaluation) operator.''
 
-u              :  ''I1'' + ''I2'' = -5  
+sum              :  ''Int1'' + ''Int2'' = -5  
 
-ffc       :  ''I1'' - ''I2'' = -11
+difference       :  ''Int1'' - ''Int2'' = -11
 
-uc          :  ''I1'' · ''I2'' = -24
+product          :  ''Int1'' · ''Int2'' = -24
 
- qu :  f(''I1''÷''I2'')=-3     uc(I1÷I2)=-2  
+integer quotient :  floor(''Int1''÷''Int2'')=-3     trunc(Int1÷Int2)=-2  
 
-        :  (''I1'',''I2'')=-2
+remainder        :  mod(''Int1'',''Int2'')=-2
 
-   :  ''I1''u''I2''u=-512
+exponentiation   :  ''Int1''<sup>''Int2''</sup>=-512
 
 ----

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

@@ -1,18 +1,18 @@
-Mc    fuc bu-    . E:
- = Iu["Gv m   !"]
-b = Iu["G    !"]
-P["Yu   ", , "  ", b]
-P["u: ",  + b]
-P["ffc: ",  - b]
-P["uc: ",  b]
-P[" qu: ", Qu[, b]]
-P[": ", M[, b]]
-P[": ", ^b]
- bc f u 17  3:
-Yu   17  3
-u: 20
-ffc: 14
-uc: 51
- qu: 5
-: 2
-: 4913
+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/zettacode.files/arithmetic.integer/matlab}}_-_{{header|octave.txt

@@ -1,8 +1,8 @@
-d(" : ")  = cf("%d", 1)
-(" b: ") b = cf("%", 1)
-+b
--b
-*b
-f(b)
-(,b)
-^b
+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/zettacode.files/arithmetic.integer/maxima.txt

@@ -1,10 +1,10 @@
-bock(
-   [: (""), b: ("b")],
-   ( + b),
-   ( - b),
-   ( * b),
-   (  b),
-   (qu(, b)),
-   ((, b)),
-   ^b
-)
+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/zettacode.files/arithmetic.integer/maxscript.txt

@@ -1,8 +1,8 @@
- = KBVu om:"F umb"
- = KBVu :"Sc ub:"
+x = getKBValue prompt:"First number"
+y = getKBValue prompt:"Second number:"
 
-f "Su: %\" ( + ) 
-f "Dffc: %\" ( - ) 
-f "Puc: %\" ( * ) 
-f "Qu: %\" (  ) 
-f "R: %\" (  )
+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)