zettacode 0.1.0 → 0.1.2

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

@@ -0,0 +1,21 @@
+''CBTJD'': 2020/03/12
+START:
+INPUT "Enter two integers (a,b):"; a!, b!
+IF a = 0 THEN END
+IF b = 0 THEN
+    PRINT "Second integer is zero. Zero not allowed for Quotient or Remainder."
+    GOTO START
+END IF
+PRINT
+PRINT "             Sum = "; a + b
+PRINT "      Difference = "; a - b
+PRINT "         Product = "; a * b
+' Notice the use of the INTEGER Divisor "\" as opposed to the regular divisor "/".
+PRINT "Integer Quotient = "; a \ b, , "* Rounds toward 0."
+PRINT "       Remainder = "; a MOD b, , "* Sign matches first operand."
+PRINT "  Exponentiation = "; a ^ b
+PRINT
+INPUT "Again? (y/N)"; a$
+IF UCASE$(a$) = "Y" THEN CLS: GOTO START
+CLS
+END

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

@@ -0,0 +1,12 @@
+
+<syntaxhighlight lang="quackery ">  $ "Please enter two integers separated by a space. "
+  input quackery
+  2dup say "Their sum is:              " +    echo cr
+  2dup say "Their difference is:       " -    echo cr
+  2dup say "Their product is: "        " *    echo cr
+  2dup say "Their integer quotient is: " /    echo cr
+  2dup say "Their remainder is:        " mod  echo cr
+       say "Their exponentiation is:   " **   echo cr
+  cr
+  say "Quotient rounds towards negative infinity." cr
+  say "Remainder matches the sign of the second argument."

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

@@ -0,0 +1,11 @@
+cat("insert number ")
+a <- scan(nmax=1, quiet=TRUE)
+cat("insert number ")
+b <- scan(nmax=1, quiet=TRUE)
+print(paste('a+b=', a+b))
+print(paste('a-b=', a-b))
+print(paste('a*b=', a*b))
+print(paste('a%/%b=', a%/%b))
+print(paste('a%%b=', a%%b))
+print(paste('a^b=', a^b))
+

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

@@ -0,0 +1,8 @@
+
+#lang racket/base
+
+(define (arithmetic x y)
+  (for ([op (list + - * / quotient remainder modulo max min gcd lcm)])
+    (printf "~s => ~s\n" `(,(object-name op) ,x ,y) (op x y))))
+
+(arithmetic 8 12)

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

@@ -0,0 +1,12 @@
+(formerly Perl 6)
+
+Note that <code>div</code> <b>requires</b> integer arguments. If you want integer division with other types, say <code>floor($a/$b)</code>.
+<syntaxhighlight lang="raku" line>my Int $a = get.floor;
+my Int $b = get.floor;
+
+say 'sum:              ', $a + $b;
+say 'difference:       ', $a - $b;
+say 'product:          ', $a * $b;
+say 'integer quotient: ', $a div $b;
+say 'remainder:        ', $a % $b;
+say 'exponentiation:   ', $a**$b;

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

@@ -0,0 +1,9 @@
+
+'  Number 1: ' print expect 0 prefer as x
+'  Number 2: ' print expect 0 prefer as y
+
+x y + "       sum: %d\n" print
+x y - "difference: %d\n" print
+x y * "   product: %d\n" print
+x y / "  quotient: %d\n" print
+x y % " remainder: %d\n" print

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

@@ -0,0 +1,51 @@
+REBOL [
+	Title: "Integer"
+	URL: http://rosettacode.org/wiki/Arithmetic/Integer
+]
+
+x: to-integer ask "Please type in an integer, and press [enter]: "
+y: to-integer ask "Please enter another integer: "
+print ""
+
+print ["Sum:"  x + y]
+print ["Difference:"  x - y]
+print ["Product:" x * y]
+
+print ["Integer quotient (coercion)                          :"  to-integer x / y]
+print ["Integer quotient (away from zero)                    :"  round x / y]
+print ["Integer quotient (halves round towards even digits)  :"  round/even x / y]
+print ["Integer quotient (halves round towards zero)         :"  round/half-down x / y]
+print ["Integer quotient (round in negative direction)       :"  round/floor x / y]
+print ["Integer quotient (round in positive direction)       :"  round/ceiling x / y]
+print ["Integer quotient (halves round in positive direction):"  round/half-ceiling x / y]
+
+print ["Remainder:"  r: x // y]
+
+; REBOL evaluates infix expressions from left to right. There are no
+; precedence rules -- whatever is first gets evaluated. Therefore when
+; performing this comparison, I put parens around the first term
+; ("sign? a") of the expression so that the value of /a/ isn't
+; compared to the sign of /b/. To make up for it, notice that I don't
+; have to use a specific return keyword. The final value in the
+; function is returned automatically.
+
+match?: func [a b][(sign? a) = sign? b]
+
+result: copy []
+if match? r x [append result "first"]
+if match? r y [append result "second"]
+
+; You can evaluate arbitrary expressions in the middle of a print, so
+; I use a "switch" to provide a more readable result based on the
+; length of the /results/ list.
+
+print [
+	"Remainder sign matches:" 
+	switch length? result [
+		0 ["neither"]
+		1 [result/1]
+		2 ["both"]
+	] 
+]
+
+print ["Exponentiation:" x ** y]

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

@@ -0,0 +1,11 @@
+There is no input, variables have to be set in code. Format is there only for output.
+
+set a = -17
+set b = 4
+echo "a+b = ".format(a+b,"%1d")
+echo "a-b = ".format(a-b,"%1d")
+echo "a*b = ".format(a*b,"%1d")
+echo "a DIV b = ".format(floor(a/b),"%1d")
+echo "a MOD b = ".format(a mod b,"%1d")
+echo "a^b = ".format(pow(a,b),"%1d")
+

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

@@ -0,0 +1,15 @@
+
+let a = int_of_string(Sys.argv[2])
+let b = int_of_string(Sys.argv[3])
+
+let sum = a + b
+let difference = a - b
+let product = a * b
+let division = a / b
+let remainder = mod(a, b)
+
+Js.log("a + b = " ++ string_of_int(sum))
+Js.log("a - b = " ++ string_of_int(difference))
+Js.log("a * b = " ++ string_of_int(product))
+Js.log("a / b = " ++ string_of_int(division))
+Js.log("a % b = " ++ string_of_int(remainder))

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

@@ -0,0 +1,10 @@
+Retro's arithmetic functions are based on those in [[Forth]]. The example is an adaption of the one from Forth.
+ 
+:arithmetic (ab-)
+  over       '\na_______=_%n s:put
+  dup        '\nb_______=_%n s:put
+  dup-pair + '\na_+_b___=_%n s:put
+  dup-pair - '\na_-_b___=_%n s:put
+  dup-pair * '\na_*_b___=_%n s:put
+  /mod       '\na_/_b___=_%n s:put
+             '\na_mod_b_=_%n\n" s:put ;

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

@@ -0,0 +1,47 @@
+All operators automatically produce integers where appropriate   (up to twenty decimal digits in the program below),
+<br>or numbers in exponential format when necessary. &amp;nbsp; (The REXX default is &amp;nbsp; '''9''' &amp;nbsp; decimal digits.)
+
+For division that produces a floating point number, the result is rounded to the nearest number that can be expressed  
+<br>within the current number of decimal digits &amp;nbsp; (in the example program below, it is &amp;nbsp; '''20''' &amp;nbsp; decimal digits).
+/*REXX program obtains two integers from the C.L. (a prompt);  displays some operations.*/
+numeric digits 20                                /*#s are round at 20th significant dig.*/
+parse arg x y .                                  /*maybe the integers are on the  C.L.  */
+
+  do while \datatype(x,'W') | \datatype(y,'W')   /*both   X  and  Y   must be integers. */
+  say "─────Enter two integer values  (separated by blanks):"
+  parse pull x y .                               /*accept two thingys from command line.*/
+  end   /*while*/
+                                                 /* [↓]  perform this  DO  loop twice.  */
+     do j=1  for 2                               /*show  A  oper  B,   then  B  oper  A.*/
+     call show 'addition'          ,  "+",   x+y
+     call show 'subtraction'       ,  "-",   x-y
+     call show 'multiplication'    ,  "*",   x*y
+     call show 'int  division'     ,  "%",   x%y,  '    [rounds down]'
+     call show 'real division'     ,  "/",   x/y
+     call show 'division remainder',  "//",  x//y, '    [sign from 1st operand]'
+     call show 'power'             ,  "**",  x**y
+
+     parse value  x  y    with    y  x           /*swap the two values and perform again*/
+     if j==1  then say copies('═', 79)           /*display a fence after the 1st round. */
+     end   /*j*/
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+show: parse arg c,o,#,?;   say right(c,25)' '  x  center(o,4)  y  " ───► "  #  ?;   return
+{{out|output|text=&amp;nbsp; when using the input of: &amp;nbsp; &amp;nbsp; <tt> 4 &amp;nbsp; -17 </tt>}}
+
+                 addition  4  +   -17  ───►  -13
+              subtraction  4  -   -17  ───►  21
+           multiplication  4  *   -17  ───►  -68
+            int  division  4  %   -17  ───►  0     [rounds down]
+            real division  4  /   -17  ───►  -0.23529411764705882353
+       division remainder  4  //  -17  ───►  4     [sign from 1st operand]
+                    power  4  **  -17  ───►  5.8207660913467407227E-11
+═══════════════════════════════════════════════════════════════════════════════
+                 addition  -17  +   4  ───►  -13
+              subtraction  -17  -   4  ───►  -21
+           multiplication  -17  *   4  ───►  -68
+            int  division  -17  %   4  ───►  -4     [rounds down]
+            real division  -17  /   4  ───►  -4.25
+       division remainder  -17  //  4  ───►  -1     [sign from 1st operand]
+                    power  -17  **  4  ───►  83521
+

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

@@ -0,0 +1,11 @@
+
+func Test a,b
+   see "a+b" + ( a + b ) + nl
+   see "a-b" + ( a - b ) + nl
+   see "a*b" + ( a * b ) + nl
+   // The quotient isn't integer, so we use the Ceil() function, which truncates it downward.
+   see "a/b" + Ceil( a / b ) + nl
+   // Remainder:
+   see "a%b" + ( a % b ) + nl
+   see "a**b" +  pow(a,b )  + nl
+

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

@@ -0,0 +1,13 @@
+
+input string "Enter number 1:"
+set "a" to "input"
+input string "Enter number 2:"
+set "b" to "input"
+
+[ "Sum: ('a' + 'b')"
+[ "Difference: ('a' - 'b')"
+[ "Product: ('a' * 'b')"
+[ "Integer Quotient: ('a' / 'b')"
+[ "Remainder: ('a' % 'b')"
+[ "Exponentiation: ('a'^'b')"
+

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

@@ -0,0 +1,12 @@
+
+puts 'Enter x and y'
+x = gets.to_i  # to check errors, use x=Integer(gets)
+y = gets.to_i
+
+puts "Sum: #{x+y}",
+     "Difference: #{x-y}",
+     "Product: #{x*y}",
+     "Quotient: #{x/y}",       # truncates towards negative infinity
+     "Quotient: #{x.fdiv(y)}", # float
+     "Remainder: #{x%y}",      # same sign as second operand
+     "Exponentiation: #{x**y}"

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

@@ -0,0 +1,9 @@
+input "1st integer: "; i1
+input "2nd integer: "; i2
+ 
+print "      Sum"; i1 + i2
+print "     Diff"; i1 - i2
+print "  Product"; i1 * i2
+if i2 <>0 then print "  Quotent "; int( i1 / i2); else print "Cannot divide by zero."
+print "Remainder"; i1 MOD i2
+print "1st raised to power of 2nd"; i1 ^ i2

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

@@ -0,0 +1,15 @@
+
+Note that this code cannot be run within the [http://play.rust-lang.org Rust playpen] as it does not support console input.
+use std::env;
+
+fn main() {
+    let args: Vec<_> = env::args().collect();
+    let a = args[1].parse::<i32>().unwrap();
+    let b = args[2].parse::<i32>().unwrap();
+
+    println!("sum:              {}", a + b);
+    println!("difference:       {}", a - b);
+    println!("product:          {}", a * b);
+    println!("integer quotient: {}", a / b); // truncates towards zero
+    println!("remainder:        {}", a % b); // same sign as first operand
+}

data/files.zettacode/arithmetic.integer/sass-scss.txt

@@ -0,0 +1,36 @@
+
+
+@function arithmetic($a,$b) {
+	@return $a + $b, $a - $b, $a * $b, ($a - ($a % $b))/$b, $a % $b;
+}
+
+Which you use with: 
+
+nth(arithmetic(10,3),1);
+
+Or each of the functions separately:
+
+@function sum($a,$b) {
+	@return $a + $b;
+}
+
+@function difference($a,$b) {
+	@return $a - $b;
+}
+
+@function product($a,$b) {
+	@return $a * $b;
+}
+
+@function integer-division($a,$b) {
+	@return ($a - ($a % $b))/$b;
+}
+
+@function remainder($a,$b) {
+	@return $a % $b;
+}
+
+@function float-division($a,$b) {
+	@return $a / $b;
+}
+

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

@@ -0,0 +1,9 @@
+val a = Console.readInt
+val b = Console.readInt
+ 
+val sum = a + b //integer addition is discouraged in print statements due to confusion with String concatenation
+println("a + b = " + sum)
+println("a - b = " + (a - b))
+println("a * b = " + (a * b))
+println("quotient of a / b = " + (a / b)) // truncates towards 0
+println("remainder of a / b = " + (a % b)) // same sign as first operand

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

@@ -0,0 +1,27 @@
+
+(define (arithmetic x y)
+  (for-each (lambda (op)
+              (write  (list op x y))
+              (display " => ")
+              (write ((eval op) x y))
+              (newline))
+            '(+ - * / quotient remainder modulo max min gcd lcm)))
+           
+(arithmetic 8 12)
+quotient - truncates towards 0
+remainder - same sign as first operand
+modulo - same sign as second operand
+ 
+  prints this:
+ 
+ (+ 8 12) => 20
+ (- 8 12) => -4
+ (* 8 12) => 96
+ (/ 8 12) => 2/3
+ (quotient 8 12) => 0
+ (remainder 8 12) => 8
+ (modulo 8 12) => 8
+ (max 8 12) => 12
+ (min 8 12) => 8
+ (gcd 8 12) => 4
+ (lcm 8 12) => 24

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

@@ -0,0 +1,20 @@
+$ include "seed7_05.s7i";
+
+const proc: main is func
+  local
+    var integer: a is 0;
+    var integer: b is 0;
+  begin
+    write("a = ");
+    readln(a);
+    write("b = ");
+    readln(b);
+ 
+    writeln("a + b = " <&amp; a + b);
+    writeln("a - b = " <&amp; a - b);
+    writeln("a * b = " <&amp; a * b);
+    writeln("a div b = " <&amp; a div b);    # Rounds towards zero
+    writeln("a rem b = " <&amp; a rem b);    # Sign of the first operand
+    writeln("a mdiv b = " <&amp; a mdiv b);  # Rounds towards negative infinity
+    writeln("a mod b = " <&amp; a mod b);    # Sign of the second operand
+  end func;

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

@@ -0,0 +1,12 @@
+ask "Enter the first number:"
+put it into number1
+
+ask "Enter the second number:"
+put it into number2
+
+put "Sum: " & number1 plus number2
+put "Difference: " & number1 minus number2
+put "Product: " & number1 multiplied by number2
+put "Integer quotient: " & number1 div number2 -- Rounding towards 0
+put "Remainder: " & number1 rem number2
+put "Exponentiation: " & number1 to the power of number2

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

@@ -0,0 +1,6 @@
+var a = Sys.scanln("First number: ").to_i;
+var b = Sys.scanln("Second number: ").to_i;
+
+%w'+ - * // % ** ^ | &amp; << >>'.each { |op|
+    "#{a} #{op} #{b} = #{a.$op(b)}".say;
+}

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

@@ -0,0 +1,9 @@
+[| :a :b |
+inform: (a + b) printString.
+inform: (a - b) printString.
+inform: (a * b) printString.
+inform: (a / b) printString.
+inform: (a // b) printString.
+inform: (a \\ b) printString.
+
+] applyTo: {Integer readFrom: (query: 'Enter a: '). Integer readFrom: (query: 'Enter b: ')}.

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

@@ -0,0 +1,28 @@
+{{works with|GNU Smalltalk}}
+| a b |
+'Input number a: ' display.
+a := (stdin nextLine) asInteger.
+'Input number b: ' display.
+b := (stdin nextLine) asInteger.
+('a+b=%1' % { a + b }) displayNl.
+('a-b=%1' % { a - b }) displayNl.
+('a*b=%1' % { a * b }) displayNl.
+('a/b=%1' % { a // b }) displayNl.
+('a%%b=%1' % { a \\ b }) displayNl.
+
+{{works with|Smalltalk/X}} (and all other Smalltalks)
+|a b|
+a := (Dialog request:'Enter first number:') asNumber.
+b := (Dialog request:'Enter second number:') asNumber.
+#( + - / * // \\ quo: rem: raisedTo: **) do:[:operator |
+    |result|
+    result := a perform:operator with:b.
+    '%P %s %P => %P\n' printf:{a . operator . b . result} on:Transcript
+].
+/ is exact division
+<br>// is truncating division (towards negative infinity) 
+<br>\\ is remainder from \\
+<br>quo: is truncating division (towards zero) 
+<br>\\ is remainder from quo:
+<br>** is just an alias for raisedTo:
+<p>Entering 10 and 3, generates:

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

@@ -0,0 +1,18 @@
+INPUT "Enter first number.":first
+INPUT "Enter second number.":second
+PRINT "The sum of";first;"and";second;"is ";first+second&"."
+PRINT "The difference between";first;"and";second;"is ";ABS(first-second)&"."
+PRINT "The product of";first;"and";second;"is ";first*second&"."
+IF second THEN
+    PRINT "The integer quotient of";first;"and";second;"is ";INTEG(first/second)&"."
+ELSE
+    PRINT "Division by zero not cool."
+ENDIF
+PRINT "The remainder being...";first%second&"."
+PRINT STR$(first);"raised to the power of";second;"is ";first^second&"."
+
+'''NOTES:''' Some curious aspects of smart BASIC to note in this code example:
+<ol>
+<li>In smart BASIC, The command INTEG is a true integer function providing only the value of the characteristic. The smart BASIC INT command calculates as a rounding function. This differs from some other versions of BASIC.</li>
+<li>smart BASIC automatically inserts spaces ahead of and behind numbers. This can cause unexpected formatting issues when combining output from numeric variables with text. In order to suppress the trailing space, you must use the ampersand (&amp;) to concatenate the numeric value with the following text (in this case, a period at the end of each sentence). In the case of leading spaces, you must convert the numeric value to text using the STR$ command (as with the last line of the code).
+</ol>

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

@@ -0,0 +1,12 @@
+
+        output = "Enter first integer:"
+  	first = input
+	output = "Enter second integer:"
+	second = input
+	output = "sum  = " first + second
+	output = "diff = " first - second
+	output = "prod = " first * second
+	output = "quot = " (qout = first / second)
+	output = "rem  = " first - (qout * second)
+	output = "expo  = " first ** second
+end

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

@@ -0,0 +1,61 @@
+As a BF derivative, SNUSP only has increment and decrement as native operations. Here are routines for other basic arithmetic upon single digit numbers and results.
+
+''See also: [[Ethiopian Multiplication]]''
+$\
+ ,
+ @
+ \=@@@-@-----#  atoi
+ >
+ ,
+ @
+ \=@@@-@-----#
+ <
+ @     #        4 copies
+ \=!/?!/->>+>>+>>+>>+<<<<<<<<?\#
+ >  | #\?<<<<<<<<+>>+>>+>>+>>-/
+ @  |
+ \==/
+ \>>>>\
+ />>>>/
+ @
+ \==!/===?\#    add
+ <   \>+<-/
+ @
+ \=@@@+@+++++#  itoa
+ .
+ <
+ @
+ \==!/===?\#    subtract
+ <   \>-<-/
+ @
+ \=@@@+@+++++#
+ .
+ !
+ /\
+ ?-             multiply
+ \/ #/?<<+>+>-==\     /==-<+<+>>?\#    /==-<<+>>?\#
+ <   \->+>+<<!/?/#   #\?\!>>+<+<-/    #\?\!>>+<<-/
+ @         /==|=========|=====\   /-\    |
+ \======<?!/>@/<-?!\>>>@/<<<-?\=>!\?/>!/@/<#
+ <         \=======|==========/   /-\  |
+ @                 \done======>>>!\?/<=/
+ \=@@@+@+++++#
+ .
+ !
+ /\
+ ?-  zero
+ \/
+ <              divmod
+ @    /-\
+ \?\<!\?/#!===+<<<\      /-\
+ | \<==@\>@\>>!/?!/=<?\>!\?/<<#
+ |      |  |  #\->->+</
+ |      \=!\=?!/->>+<<?\#
+ @            #\?<<+>>-/
+ \=@@@+@+++++#
+ .
+ <
+ @
+ \=@@@+@+++++#
+ .
+ #

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

@@ -0,0 +1,68 @@
+{{works with|Oracle}}
+
+-- test.sql
+-- Tested in SQL*plus
+
+drop table test;
+
+create table test (a integer, b integer);
+
+insert into test values ('&&A','&&B');
+
+commit;
+
+select a-b difference from test;
+
+select a*b product from test;
+
+select trunc(a/b) integer_quotient from test;  
+
+select mod(a,b) remainder from test;
+
+select power(a,b) exponentiation from test;
+
+
+
+SQL> @test.sql
+
+Table dropped.
+
+
+Table created.
+
+Enter value for a: 3
+Enter value for b: 4
+old   1: insert into test values ('&&A','&&B')
+new   1: insert into test values ('3','4')
+
+1 row created.
+
+
+Commit complete.
+
+
+DIFFERENCE
+----------
+        -1
+
+
+   PRODUCT
+----------
+        12
+
+
+INTEGER_QUOTIENT
+----------------
+               0
+
+
+ REMAINDER
+----------
+         3
+
+
+EXPONENTIATION
+--------------
+            81
+   
+

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

@@ -0,0 +1,15 @@
+The only operation that the SSEM supports natively is substraction. This program uses the <tt>001 Sub.</tt> instruction to find the difference between <i>a</i> and <i>b</i>, assuming they are loaded into storage addresses 20 and 21 respectively.
+00101000000000100000000000000000   0. -20 to c
+10100000000001100000000000000000   1. c to 5
+10100000000000100000000000000000   2. -5 to c
+10101000000000010000000000000000   3. Sub. 21
+00000000000001110000000000000000   4. Stop
+00000000000000000000000000000000   5. 0
+The routine is slightly more complicated than it would otherwise be, because the SSEM cannot load a value into the accumulator (<tt>c</tt> register) from storage without negating it in the process—so we have to shuffle the negation of <i>a</i> back out into storage and then negate it again before we can subtract <i>b</i> from it. This does, however, make it easy to implement addition using negation and subtraction. In this program, we first negate <i>a</i>; then subtract <i>b</i>, and store the result; and finally negate that result, thereby obtaining the sum of the two integers.
+00101000000000100000000000000000   0. -20 to c
+10101000000000010000000000000000   1. Sub. 21
+10100000000001100000000000000000   2. c to 5
+10100000000000100000000000000000   3. -5 to c
+00000000000001110000000000000000   4. Stop
+00000000000000000000000000000000   5. 0
+A multiplication program will be found at [[Function definition#SSEM]], and one that performs integer division at [[Loops/For with a specified step#SSEM]].

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

@@ -0,0 +1,13 @@
+val () = let
+  val a = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn)))
+  val b = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn)))
+in
+  print ("a + b = "   ^ Int.toString (a + b)   ^ "\n");
+  print ("a - b = "   ^ Int.toString (a - b)   ^ "\n");
+  print ("a * b = "   ^ Int.toString (a * b)   ^ "\n");
+  print ("a div b = " ^ Int.toString (a div b) ^ "\n");         (* truncates towards negative infinity *)
+  print ("a mod b = " ^ Int.toString (a mod b) ^ "\n");         (* same sign as second operand *)
+  print ("a quot b = " ^ Int.toString (Int.quot (a, b)) ^ "\n");(* truncates towards 0 *)
+  print ("a rem b = " ^ Int.toString (Int.rem (a, b)) ^ "\n");  (* same sign as first operand *)
+  print ("~a = "      ^ Int.toString (~a)      ^ "\n")          (* unary negation, unusual notation compared to other languages *)
+end

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

@@ -0,0 +1,11 @@
+
+let a = 6 
+let b = 4
+
+print("sum =\(a+b)")
+print("difference = \(a-b)")
+print("product = \(a*b)")
+print("Integer quotient = \(a/b)")
+print("Remainder = (a%b)")
+print("No operator for Exponential")
+