zettacode 0.1.3 → 0.1.4

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

@@ -0,0 +1,158 @@
+Basic program
+
+window 1, @"Integer Arithmetic", ( 0, 0, 400, 300 )
+
+NSInteger a = 25
+NSInteger b = 53
+
+print "addition        "a" + "b" = " (a + b)
+print "subtraction     "a" - "b" = " (a - b)
+print "multiplication  "a" * "b" = " (a * b)
+print "division        "a" / "b" = " (a / b)
+printf @"float division  %ld / %ld = %f", a, b, (float)a / (float)b
+print "modulo          "a" % "b" = " (a mod b)
+print "power           "a" ^ "b" = " (a ^ b)
+
+HandleEvents
+
+
+Output:
+
+addition:       25 + 53 = 78
+subtraction:    25 - 53 = -28
+multiplication: 25 * 53 = 1325
+division:       25 / 53 = 0
+float division: 25 / 53 = 0.471698
+modulo:         25 mod 53 = 25
+power:          25 ^ 53 = 1.232595e+74
+
+
+Standalone Intel, M1, M2 Macintosh application with user input
+
+
+_window = 1
+begin enum 1
+_int1Label
+_int1Field
+_int2Label
+_int2Field
+_calcResults
+_calcBtn
+end enum
+
+void local fn BuildWindow
+CGRect r
+
+r = fn CGRectMake( 0, 0, 480, 360 )
+window _window, @"Integer Arithmetic", r, NSWindowStyleMaskTitled + NSWindowStyleMaskClosable + NSWindowStyleMaskMiniaturizable
+
+r = fn CGRectMake( 240, 320, 150, 24 )
+textlabel _int1Label, @"Enter first integer:", r, _window
+ControlSetAlignment( _int1Label, NSTextAlignmentRight )
+r = fn CGRectMake( 400, 322, 60, 24 )
+textfield _int1Field, YES, @"25", r, _window
+ControlSetAlignment( _int1Field, NSTextAlignmentCenter )
+ControlSetUsesSingleLineMode( _int1Field, YES )
+ControlSetFormat( _int1Field, @"0123456789-", YES, 5, NULL )
+
+r = fn CGRectMake( 240, 290, 150, 24 )
+textlabel _int2Label, @"Enter second integer:", r, _window
+ControlSetAlignment( _int2Label, NSTextAlignmentRight )
+r = fn CGRectMake( 400, 292, 60, 24 )
+textfield _int2Field, YES, @"53", r, _window
+ControlSetAlignment( _int2Field, NSTextAlignmentCenter )
+ControlSetUsesSingleLineMode( _int2Field, YES )
+ControlSetFormat( _int2Field, @"0123456789-", YES, 5, NULL )
+
+r = fn CGRectMake( 50, 60, 380, 200 )
+textview _calcResults, r,,, _window
+TextViewSetTextContainerInset( _calcResults, fn CGSizeMake( 10, 20 ) )
+TextSetFontWithName( _calcResults, @"Menlo", 13.0 )
+TextViewSetEditable( _calcResults, NO )
+
+r = fn CGRectMake( 370, 13, 100, 32 )
+button _calcBtn,,, @"Calculate", r
+end fn
+
+local fn PerformCalculations
+CFStringRef tempStr
+
+NSInteger i1 = fn ControlIntegerValue( _int1Field )
+NSInteger i2 = fn ControlIntegerValue( _int2Field )
+
+CFMutableStringRef mutStr = fn MutableStringWithCapacity( 0 )
+
+// Display inout integers
+tempStr = fn StringWithFormat( @"Number 1: %ld\nNumber 2: %ld\n\n", i1, i2 )
+MutableStringAppendString( mutStr, tempStr )
+
+// Add
+tempStr = fn StringWithFormat( @"Addition: %ld + %ld = %ld\n", i1, i2, i1 + i2 )
+MutableStringAppendString( mutStr, tempStr )
+
+// Subtract
+tempStr = fn StringWithFormat( @"Subtraction: %ld - %ld = %ld\n", i1, i2, i1 - i2 )
+MutableStringAppendString( mutStr, tempStr )
+
+// Multiply
+tempStr = fn StringWithFormat( @"Multiplication: %ld * %ld = %ld\n", i1, i2, i1 * i2 )
+MutableStringAppendString( mutStr, tempStr )
+
+if ( i2 != 0 )
+
+// Divide
+tempStr = fn StringWithFormat( @"Integer Division: %ld / %ld = %ld\n", i1, i2, i1 / i2 )
+MutableStringAppendString( mutStr, tempStr )
+
+// Float Divide
+tempStr = fn StringWithFormat( @"Float Division: %ld / %ld = %f\n", i1, i2, (float)i1 / (float)i2 )
+MutableStringAppendString( mutStr, tempStr )
+
+// mod
+tempStr = fn StringWithFormat( @"Modulo: %ld mod %ld = %ld remainder\n", i1, i2, i1 mod i2 )
+MutableStringAppendString( mutStr, tempStr )
+
+// power
+tempStr = fn StringWithFormat( @"Power: %ld ^ %ld = %e\n", i1, i2, i1 ^ i2 )
+MutableStringAppendString( mutStr, tempStr )
+
+else
+
+MutableStringAppendString( mutStr, @"Cannot divide by zero." )
+
+end if
+
+TextSetString( _calcResults, mutStr )
+end fn
+
+void local fn DoDialog( ev as long, tag as long, wnd as long )
+'~'1
+select ( ev )
+case _btnClick
+select ( tag )
+case _calcBtn : fn PerformCalculations
+end select
+case _windowWillClose : end
+end select
+end fn
+
+on dialog fn DoDialog
+
+fn BuildWindow
+
+HandleEvents
+
+
+Output:
+
+Number 1: 25
+Number 2: 53
+
+Addition: 25 + 53 = 78
+Subtraction: 25 - 53 = -28
+Multiplication: 25 * 53 = 1325
+Integer Division: 25 / 53 = 0
+Float Division: 25 / 53 = 0.471698
+Modulo: 25 mod 53 = 25 remainder
+Power: 25 ^ 53 = 1.232595e+74
+

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

@@ -0,0 +1,30 @@
+Public Sub Main()
+  Dim a, b As String
+  Dim c, d As Integer
+
+  Print "Enter two integer numbers, separated by space:"
+  Input a, b
+
+  c = CInt(a)
+  d = CInt(b)
+
+  Print "Sum: " & (c + d)
+  Print "Difference:" & (c - d)
+  Print "Product: " & (c * d)
+  Print "Integer: " & (c Div d)
+  Print "Remainder: " & (c Mod d)
+  Print "Exponentiation: " & (c ^ d)
+
+End
+
+Output:
+
+Enter two integer numbers, separated by space:
+8 1
+Sum: 9
+Difference:7
+Product: 8
+Integer: 8
+Remainder: 0
+Exponentiation: 8
+

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

@@ -0,0 +1,15 @@
+run := function()
+  local a, b, f;
+  f := InputTextUser();
+  Print("a =\n");
+  a := Int(Chomp(ReadLine(f)));
+  Print("b =\n");
+  b := Int(Chomp(ReadLine(f)));
+  Display(Concatenation(String(a), " + ", String(b), " = ", String(a + b)));
+  Display(Concatenation(String(a), " - ", String(b), " = ", String(a - b)));
+  Display(Concatenation(String(a), " * ", String(b), " = ", String(a * b)));
+  Display(Concatenation(String(a), " / ", String(b), " = ", String(QuoInt(a, b)))); # toward 0
+  Display(Concatenation(String(a), " mod ", String(b), " = ", String(RemInt(a, b)))); # nonnegative
+  Display(Concatenation(String(a), " ^ ", String(b), " = ", String(a ^ b)));
+  CloseStream(f);
+end;

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

@@ -0,0 +1,23 @@
+Note: Using ''init:int'' and the ''return'' from the init block was introduced in release 0.43.92, February 2019.
+
+[indent=4]
+/*
+   Arithmethic/Integer, in Genie
+   valac arithmethic-integer.gs
+*/
+
+init:int
+    a:int = 0
+    b:int = 0
+    if args.length > 2 do b = int.parse(args[2])
+    if args.length > 1 do a = int.parse(args[1])
+
+    print @"a+b: $a plus  $b is $(a+b)"
+    print @"a-b: $a minus $b is $(a-b)"
+    print @"a*b: $a times $b is $(a*b)"
+    print @"a/b: $a by    $b quotient is  $(a/b)  (rounded mode is TRUNCATION)"
+    print @"a%b: $a by    $b remainder is $(a%b)  (sign matches first operand)"
+
+    print "\nGenie does not include a raise to power operator"
+
+    return 0

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

@@ -0,0 +1,7 @@
+R (m) ;
+R (n) ;
+m n + P;
+m n - P;
+m n × P;
+m n div P;
+m n rem P;

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

@@ -0,0 +1,66 @@
+===int===
+package main
+
+import "fmt"
+
+func main() {
+    var a, b int
+    fmt.Print("enter two integers: ")
+    fmt.Scanln(&a, &b)
+    fmt.Printf("%d + %d = %d\n", a, b, a+b)
+    fmt.Printf("%d - %d = %d\n", a, b, a-b)
+    fmt.Printf("%d * %d = %d\n", a, b, a*b)
+    fmt.Printf("%d / %d = %d\n", a, b, a/b)  // truncates towards 0
+    fmt.Printf("%d %% %d = %d\n", a, b, a%b) // same sign as first operand
+    // no exponentiation operator
+}
+{{out|Example run}}
+
+enter two integers: -5 3
+-5 + 3 = -2
+-5 - 3 = -8
+-5 * 3 = -15
+-5 / 3 = -1
+-5 % 3 = -2
+
+===big.Int===
+package main
+
+import (
+    "fmt"
+    "math/big"
+)
+
+func main() {
+    var a, b, c big.Int
+    fmt.Print("enter two integers: ")
+    fmt.Scan(&a, &b)
+    fmt.Printf("%d + %d = %d\n", &a, &b, c.Add(&a, &b))
+    fmt.Printf("%d - %d = %d\n", &a, &b, c.Sub(&a, &b))
+    fmt.Printf("%d * %d = %d\n", &a, &b, c.Mul(&a, &b))
+
+    // Quo, Rem functions work like Go operators on int:
+    // quo truncates toward 0,
+    // and a non-zero rem has the same sign as the first operand.
+    fmt.Printf("%d quo %d = %d\n", &a, &b, c.Quo(&a, &b))
+    fmt.Printf("%d rem %d = %d\n", &a, &b, c.Rem(&a, &b))
+
+    // Div, Mod functions do Euclidean division:
+    // the result m = a mod b is always non-negative,
+    // and for d = a div b, the results d and m give d*y + m = x.
+    fmt.Printf("%d div %d = %d\n", &a, &b, c.Div(&a, &b))
+    fmt.Printf("%d mod %d = %d\n", &a, &b, c.Mod(&a, &b))
+
+    // as with int, no exponentiation operator
+}
+{{out|Example run}}
+
+enter two integers: -5 3
+-5 + 3 = -2
+-5 - 3 = -8
+-5 * 3 = -15
+-5 quo 3 = -1
+-5 rem 3 = -2
+-5 div 3 = -2
+-5 mod 3 = 1
+

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

@@ -0,0 +1,18 @@
+'''Solution:'''
+def arithmetic = { a, b ->
+    println """
+       a + b =        ${a} + ${b} = ${a + b}
+       a - b =        ${a} - ${b} = ${a - b}
+       a * b =        ${a} * ${b} = ${a * b}
+       a / b =        ${a} / ${b} = ${a / b}   !!! Converts to floating point!
+(int)(a / b) = (int)(${a} / ${b}) = ${(int)(a / b)}              !!! Truncates downward after the fact
+ a.intdiv(b) =  ${a}.intdiv(${b}) = ${a.intdiv(b)}              !!! Behaves as if truncating downward, actual implementation varies
+       a % b =        ${a} % ${b} = ${a % b}
+
+Exponentiation is also a base arithmetic operation in Groovy, so:
+      a ** b =       ${a} ** ${b} = ${a ** b}
+"""
+}
+
+'''Test:'''
+arithmetic(5,3)

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

@@ -0,0 +1,11 @@
+procedure Test( a, b )
+   ? "a+b", a + b
+   ? "a-b", a - b
+   ? "a*b", a * b
+   // The quotient isn't integer, so we use the Int() function, which truncates it downward.
+   ? "a/b", Int( a / b )
+   // Remainder:
+   ? "a%b", a % b
+   // Exponentiation is also a base arithmetic operation
+   ? "a**b", a ** b
+   return

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

@@ -0,0 +1,16 @@
+
+main = do
+  a <- readLn :: IO Integer
+  b <- readLn :: IO Integer
+  putStrLn $ "a + b = " ++ show (a + b)
+  putStrLn $ "a - b = " ++ show (a - b)
+  putStrLn $ "a * b = " ++ show (a * b)
+  putStrLn $ "a to the power of b = " ++ show (a ** b)
+  putStrLn $ "a to the power of b = " ++ show (a ^ b)
+  putStrLn $ "a to the power of b = " ++ show (a ^^ b)
+  putStrLn $ "a `div` b = "  ++ show (a `div` b)  -- truncates towards negative infinity
+  putStrLn $ "a `mod` b = "  ++ show (a `mod` b)  -- same sign as second operand
+  putStrLn $ "a `divMod` b = "  ++ show (a `divMod` b)
+  putStrLn $ "a `quot` b = " ++ show (a `quot` b) -- truncates towards 0
+  putStrLn $ "a `rem` b = "  ++ show (a `rem` b)  -- same sign as first operand
+  putStrLn $ "a `quotRem` b = "  ++ show (a `quotRem` b)

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

@@ -0,0 +1,13 @@
+class BasicIntegerArithmetic {
+    public static function main() {
+        var args =Sys.args();
+        if (args.length < 2) return;
+        var a = Std.parseFloat(args[0]);
+        var b = Std.parseFloat(args[1]);
+        trace("a+b = " + (a+b));
+        trace("a-b = " + (a-b));
+        trace("a*b = " + (a*b));
+        trace("a/b = " + (a/b));
+        trace("a%b = " + (a%b));
+    }
+}

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

@@ -0,0 +1,26 @@
+All numeric is 8-byte-float. Conversions are by INT, NINT, FLOOR, CEILING, or Formatted IO
+DLG(Edit=A, Edit=B, TItle='Enter numeric A and B')
+WRITE(Name) A, B
+WRITE() '              A + B = ', A + B
+WRITE() '              A - B = ', A - B
+WRITE() '              A * B = ', A * B
+WRITE() '              A / B = ', A / B          ! no truncation
+WRITE() 'truncate      A / B = ', INT(A / B)     ! truncates towards 0
+WRITE() 'round next    A / B = ', NINT(A / B)    ! truncates towards next integer
+WRITE() 'round down    A / B = ', FLOOR(A / B)   ! truncates towards minus infinity
+WRITE() 'round up      A / B = ', CEILING(A / B) ! truncates towards plus infinity
+WRITE() 'remainder of  A / B = ', MOD(A, B)      ! same sign as A
+WRITE() 'A to the power of B = ', A ^ B
+WRITE() 'A to the power of B = ', A ** B
+A=5; B=-4;
+              A + B = 1 
+              A - B = 9 
+              A * B = -20 
+              A / B = -1.25 
+truncate      A / B = -1 
+round next    A / B = -1 
+round down    A / B = -2 
+round up      A / B = -1 
+remainder of  A / B = 1 
+A to the power of B = 16E-4 
+A to the power of B = 16E-4 

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

@@ -0,0 +1,14 @@
+I64 *a, *b;
+a = Str2I64(GetStr("Enter your first number: "));
+b = Str2I64(GetStr("Enter your second number: "));
+
+if (b == 0)
+  Print("Error: The second number must not be zero.\n");
+else {
+  Print("a + b = %d\n", a + b);
+  Print("a - b = %d\n", a - b);
+  Print("a * b = %d\n", a * b);
+  Print("a / b = %d\n", a / b); /* rounds down */
+  Print("a % b = %d\n", a % b); /* same sign as first operand */
+  Print("a ` b = %d\n", a ` b);
+}

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

@@ -0,0 +1,11 @@
+main
+	a $= integer(in(' ')); ignore
+	b $= integer(in('\n')); ignore
+	
+	print("Sum:"		, a + b)
+	print("Difference:", a - b)
+	print("Product:"	, a * b)
+	print("Quotient:"	, a / b) // rounds towards zero
+	print("Modulus:"	, a % b) // same sign as first operand
+	print("Exponent:"	, a ^ b)
+}

data/files.zettacode2/arithmetic.integer/icon}}_and_{{header|unicon.txt

@@ -0,0 +1,13 @@
+procedure main()
+writes("Input 1st integer a := ")
+a := integer(read())
+writes("Input 2nd integer b := ")
+b := integer(read())
+
+write(" a + b = ",a+b)
+write(" a - b = ",a-b)
+write(" a * b = ",a*b)
+write(" a / b = ",a/b, " rounds toward 0")
+write(" a % b = ",a%b, " remainder sign matches a")
+write(" a ^ b = ",a^b)
+end

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

@@ -0,0 +1,27 @@
+
+Enter Two Numbers is a room.
+
+Numerically entering is an action applying to one number. Understand "[number]" as numerically entering.
+
+The first number is a number that varies.
+
+After numerically entering for the first time:
+	now the first number is the number understood.
+
+After numerically entering for the second time:
+	let A be the first number;
+	let B be the number understood;
+	say "[A] + [B] = [A + B]."; [operator syntax]
+	say "[A] - [B] = [A minus B]."; [English syntax]
+	let P be given by P = A * B where P is a number; [inline equation]
+	say "[A] * [B] = [P].";
+	let Q be given by the Division Formula; [named equation]
+	say "[A] / [B] = [Q].";
+	say "[A] mod [B] = [remainder after dividing A by B].";
+	end the story.
+
+Equation - Division Formula
+	Q = A / B
+where Q is a number, A is a number, and B is a number.
+
+This solution shows four syntaxes: mathematical operators, English operators, inline equations, and named equations. Division rounds toward zero, and the remainder has the same sign as the quotient.

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

@@ -0,0 +1,18 @@
+calc =:    + , - , * , <.@% , |~ , ^
+The function <code>calc</code> constructs a list of numeric results for this task. The implementation of integer division we use here (<code><.@%.</code>) rounds down (towards negative infinity), and this is compatible with the remainder implementation we use here.
+   17 calc 3
+20 14 51 5 2 4913
+
+The function <code>bia</code> assembles these results, textually:
+
+labels  =: ];.2 'Sum: Difference: Product: Quotient: Remainder: Exponentiation: '
+combine =: ,. ":@,.
+bia     =: labels combine calc
+
+   17 bia 3
+Sum:              20
+Difference:       14
+Product:          51
+Quotient:          5
+Remainder:         2
+Exponentiation: 4913

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

@@ -0,0 +1,22 @@
+import java.util.Scanner;
+
+public class IntegerArithmetic {
+    public static void main(String[] args) {
+        // Get the 2 numbers from command line arguments
+        Scanner sc = new Scanner(System.in);
+        int a = sc.nextInt();
+        int b = sc.nextInt();
+
+        int sum = a + b;        // The result of adding 'a' and 'b' (Note: integer addition is discouraged in print statements due to confusion with string concatenation)
+        int difference = a - b; // The result of subtracting 'b' from 'a'
+        int product = a * b;    // The result of multiplying 'a' and 'b'
+        int division = a / b;   // The result of dividing 'a' by 'b' (Note: 'division' does not contain the fractional result)
+        int remainder = a % b;  // The remainder of dividing 'a' by 'b'
+
+        System.out.println("a + b = " + sum);
+        System.out.println("a - b = " + difference);
+        System.out.println("a * b = " + product);
+        System.out.println("quotient of a / b = " + division);   // truncates towards 0
+        System.out.println("remainder of a / b = " + remainder);   // same sign as first operand
+    }
+}

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

@@ -0,0 +1,30 @@
+===WScript===
+{{works with|JScript}}
+{{works with|SpiderMonkey}}
+Note that the operators work the same in all versions of JavaScript; the requirement for specific implementations is in order to get user input.
+var a = parseInt(get_input("Enter an integer"), 10);
+var b = parseInt(get_input("Enter an integer"), 10);
+
+WScript.Echo("a = " + a);
+WScript.Echo("b = " + b);
+WScript.Echo("sum: a + b = "        + (a + b));
+WScript.Echo("difference: a - b = " + (a - b));
+WScript.Echo("product: a * b = "    + (a * b));
+WScript.Echo("quotient: a / b = "   + (a / b | 0)); // "| 0" casts it to an integer
+WScript.Echo("remainder: a % b = "  + (a % b));
+
+function get_input(prompt) {
+    output(prompt);
+    try {
+        return WScript.StdIn.readLine();
+    } catch(e) {
+        return readline();
+    }
+}
+function output(prompt) {
+    try {
+        WScript.Echo(prompt);
+    } catch(e) {
+        print(prompt);
+    }
+}

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

@@ -0,0 +1,17 @@
+# Lines which do not have two integers are skipped:
+
+def arithmetic:
+  split(" ") | select(length > 0) | map(tonumber)
+  | if length > 1 then
+    .[0] as $a | .[1] as $b
+    | "For a = \($a) and b = \($b):\n" +
+      "a + b = \($a + $b)\n" +
+      "a - b = \($a - $b)\n" +
+      "a * b = \($a * $b)\n" +
+      "a/b|floor = \($a / $b | floor)\n" +
+      "a % b = \($a % $b)\n" +
+      "a | exp = \($a | exp)\n"
+    else empty
+    end ;
+
+arithmetic

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

@@ -0,0 +1,33 @@
+"use strict";
+/* Arthimetic/Integer, in Jsish */
+var line = console.input();
+var nums = line.match(/^\s*([+-]?[0-9]+)\s+([+-]?[0-9]+)\s*/);
+var a = Number(nums[1]);
+var b = Number(nums[2]);
+
+puts("A is ", a, ", B is ", b);
+puts("Sum               A + B is ", a + b);
+puts("Difference        A - B is ", a - b);
+puts("Product           A * B is ", a * b);
+puts("Integer quotient  A / B is ", a / b | 0, " truncates toward 0");
+puts("Remainder         A % B is ", a % b, " sign follows first operand");
+puts("Exponentiation    A to the power B is ", Math.pow(a, b));
+
+/*
+=!INPUTSTART!=
+7 4
+=!INPUTEND!=
+*/
+
+
+/*
+=!EXPECTSTART!=
+A is  7 , B is  4
+Sum               A + B is  11
+Difference        A - B is  3
+Product           A * B is  28
+Integer quotient  A / B is  1  truncates toward 0
+Remainder         A % B is  3  sign follows first operand
+Exponentiation    A to the power B is  2401
+=!EXPECTEND!=
+*/

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

@@ -0,0 +1,5 @@
+function arithmetic (a = parse(Int, readline()), b = parse(Int, readline()))
+  for op in  [+,-,*,div,rem]
+    println("a $op b = $(op(a,b))")
+  end
+end

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

@@ -0,0 +1,41 @@
+// version 1.1
+
+fun main(args: Array<String>) {
+    val r = Regex("""-?\d+[ ]+-?\d+""")
+    while(true) {
+        print("Enter two integers separated by space(s) or q to quit: ")
+        val input: String = readLine()!!.trim()
+        if (input == "q" || input == "Q") break
+        if (!input.matches(r)) {
+            println("Invalid input, try again")
+            continue
+        }
+        val index = input.lastIndexOf(' ')
+        val a = input.substring(0, index).trimEnd().toLong()
+        val b = input.substring(index + 1).toLong()
+        println("$a + $b = ${a + b}")
+        println("$a - $b = ${a - b}")
+        println("$a * $b = ${a * b}")
+        if (b != 0L) {
+            println("$a / $b = ${a / b}")  // rounds towards zero
+            println("$a % $b = ${a % b}")  // if non-zero, matches sign of first operand
+        }
+        else {
+            println("$a / $b = undefined")
+            println("$a % $b = undefined")
+        }
+        val d = Math.pow(a.toDouble(), b.toDouble())
+        print("$a ^ $b = ")
+        if (d % 1.0 == 0.0) {
+            if (d >= Long.MIN_VALUE.toDouble() &amp;&amp; d <= Long.MAX_VALUE.toDouble())
+                println("${d.toLong()}")
+            else
+                println("out of range")
+        }
+        else if (!d.isFinite())
+            println("not finite")
+        else
+            println("not integral")
+        println()
+    }
+}

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

@@ -0,0 +1,2 @@
+{{VI snippet}}<br/>
+[[File:LabVIEW_Arithmetic_Integer.png]]

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

@@ -0,0 +1,23 @@
+Translation of Racket
+
+{def arithmetic 
+ {lambda {:x :y}
+  {S.map {{lambda {:x :y :op} 
+                  {br}applying :op on :x & :y returns {:op :x :y}} :x :y}
+         + - * / % pow max min = > <}}}
+-> arithmetic
+
+{arithmetic 8 12}
+-> 
+applying + on 8 &amp; 12 returns 20 
+applying - on 8 &amp; 12 returns -4 
+applying * on 8 &amp; 12 returns 96 
+applying / on 8 &amp; 12 returns 0.6666666666666666 
+applying % on 8 &amp; 12 returns 8 
+applying pow on 8 &amp; 12 returns 68719476736 
+applying max on 8 &amp; 12 returns 12 
+applying min on 8 &amp; 12 returns 8 
+applying = on 8 &amp; 12 returns false 
+applying > on 8 &amp; 12 returns false 
+applying < on 8 &amp; 12 returns true
+