zettacode 0.1.0 → 0.1.1

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

@@ -1,158 +1,158 @@
-Bc 
+Basic program
 
- 1, @"I Ac", ( 0, 0, 400, 300 )
+window 1, @"Integer Arithmetic", ( 0, 0, 400, 300 )
 
-NSI  = 25
-NSI b = 53
+NSInteger a = 25
+NSInteger b = 53
 
- "        "" + "b" = " ( + b)
- "ubc     "" - "b" = " ( - b)
- "uc  "" * "b" = " ( * b)
- "        ""  "b" = " (  b)
-f @"f   %  % = %f", , b, (f)  (f)b
- "u          "" % "b" = " (  b)
- "           "" ^ "b" = " ( ^ b)
+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)
 
-HE
+HandleEvents
 
 
-Ouu:
+Output:
 
-:       25 + 53 = 78
-ubc:    25 - 53 = -28
-uc: 25 * 53 = 1325
-:       25  53 = 0
-f : 25  53 = 0.471698
-u:         25  53 = 25
-:          25 ^ 53 = 1.232595+74
+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
 
 
-S I, M1, M2 Mc c  u u
+Standalone Intel, M1, M2 Macintosh application with user input
 
 
-_ = 1
-b u 1
-_1Lb
-_1F
-_2Lb
-_2F
-_ccRu
-_ccB
- u
+_window = 1
+begin enum 1
+_int1Label
+_int1Field
+_int2Label
+_int2Field
+_calcResults
+_calcBtn
+end enum
 
- c f BuW
-CGRc 
+void local fn BuildWindow
+CGRect r
 
- = f CGRcM( 0, 0, 480, 360 )
- _, @"I Ac", , NSWSMT + NSWSMCb + NSWSMMuzb
+r = fn CGRectMake( 0, 0, 480, 360 )
+window _window, @"Integer Arithmetic", r, NSWindowStyleMaskTitled + NSWindowStyleMaskClosable + NSWindowStyleMaskMiniaturizable
 
- = f CGRcM( 240, 320, 150, 24 )
-b _1Lb, @"E f :", , _
-CSA( _1Lb, NSTAR )
- = f CGRcM( 400, 322, 60, 24 )
-f _1F, YES, @"25", , _
-CSA( _1F, NSTAC )
-CSUSLM( _1F, YES )
-CSF( _1F, @"0123456789-", YES, 5, NULL )
+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 )
 
- = f CGRcM( 240, 290, 150, 24 )
-b _2Lb, @"E c :", , _
-CSA( _2Lb, NSTAR )
- = f CGRcM( 400, 292, 60, 24 )
-f _2F, YES, @"53", , _
-CSA( _2F, NSTAC )
-CSUSLM( _2F, YES )
-CSF( _2F, @"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 )
 
- = f CGRcM( 50, 60, 380, 200 )
- _ccRu, ,,, _
-TVSTCI( _ccRu, f CGSzM( 10, 20 ) )
-TSFWN( _ccRu, @"M", 13.0 )
-TVSEb( _ccRu, NO )
+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 )
 
- = f CGRcM( 370, 13, 100, 32 )
-bu _ccB,,, @"Ccu", 
- f
+r = fn CGRectMake( 370, 13, 100, 32 )
+button _calcBtn,,, @"Calculate", r
+end fn
 
-c f PfCcu
-CFSRf S
+local fn PerformCalculations
+CFStringRef tempStr
 
-NSI 1 = f CIVu( _1F )
-NSI 2 = f CIVu( _2F )
+NSInteger i1 = fn ControlIntegerValue( _int1Field )
+NSInteger i2 = fn ControlIntegerValue( _int2Field )
 
-CFMubSRf uS = f MubSWCc( 0 )
+CFMutableStringRef mutStr = fn MutableStringWithCapacity( 0 )
 
- D u 
-S = f SWF( @"Nub 1: %\Nub 2: %\\", 1, 2 )
-MubSAS( uS, S )
+// Display inout integers
+tempStr = fn StringWithFormat( @"Number 1: %ld\nNumber 2: %ld\n\n", i1, i2 )
+MutableStringAppendString( mutStr, tempStr )
 
- A
-S = f SWF( @"A: % + % = %\", 1, 2, 1 + 2 )
-MubSAS( uS, S )
+// Add
+tempStr = fn StringWithFormat( @"Addition: %ld + %ld = %ld\n", i1, i2, i1 + i2 )
+MutableStringAppendString( mutStr, tempStr )
 
- Subc
-S = f SWF( @"Subc: % - % = %\", 1, 2, 1 - 2 )
-MubSAS( uS, S )
+// Subtract
+tempStr = fn StringWithFormat( @"Subtraction: %ld - %ld = %ld\n", i1, i2, i1 - i2 )
+MutableStringAppendString( mutStr, tempStr )
 
- Mu
-S = f SWF( @"Muc: % * % = %\", 1, 2, 1 * 2 )
-MubSAS( uS, S )
+// Multiply
+tempStr = fn StringWithFormat( @"Multiplication: %ld * %ld = %ld\n", i1, i2, i1 * i2 )
+MutableStringAppendString( mutStr, tempStr )
 
-f ( 2 != 0 )
+if ( i2 != 0 )
 
- D
-S = f SWF( @"I D: %  % = %\", 1, 2, 1  2 )
-MubSAS( uS, S )
+// Divide
+tempStr = fn StringWithFormat( @"Integer Division: %ld / %ld = %ld\n", i1, i2, i1 / i2 )
+MutableStringAppendString( mutStr, tempStr )
 
- F D
-S = f SWF( @"F D: %  % = %f\", 1, 2, (f)1  (f)2 )
-MubSAS( uS, S )
+// Float Divide
+tempStr = fn StringWithFormat( @"Float Division: %ld / %ld = %f\n", i1, i2, (float)i1 / (float)i2 )
+MutableStringAppendString( mutStr, tempStr )
 
- 
-S = f SWF( @"Mu: %  % = % \", 1, 2, 1  2 )
-MubSAS( uS, S )
+// mod
+tempStr = fn StringWithFormat( @"Modulo: %ld mod %ld = %ld remainder\n", i1, i2, i1 mod i2 )
+MutableStringAppendString( mutStr, tempStr )
 
- 
-S = f SWF( @"P: % ^ % = %\", 1, 2, 1 ^ 2 )
-MubSAS( uS, S )
+// power
+tempStr = fn StringWithFormat( @"Power: %ld ^ %ld = %e\n", i1, i2, i1 ^ i2 )
+MutableStringAppendString( mutStr, tempStr )
 
+else
 
+MutableStringAppendString( mutStr, @"Cannot divide by zero." )
 
-MubSAS( uS, @"C  b z." )
+end if
 
- f
+TextSetString( _calcResults, mutStr )
+end fn
 
-TSS( _ccRu, uS )
- f
-
- c f DD(   ,   ,    )
+void local fn DoDialog( ev as long, tag as long, wnd as long )
 '~'1
-c (  )
-c _bCc
-c (  )
-c _ccB : f PfCcu
- c
-c _WC : 
- c
- f
+select ( ev )
+case _btnClick
+select ( tag )
+case _calcBtn : fn PerformCalculations
+end select
+case _windowWillClose : end
+end select
+end fn
 
-  f DD
+on dialog fn DoDialog
 
-f BuW
+fn BuildWindow
 
-HE
+HandleEvents
 
 
-Ouu:
+Output:
 
-Nub 1: 25
-Nub 2: 53
+Number 1: 25
+Number 2: 53
 
-A: 25 + 53 = 78
-Subc: 25 - 53 = -28
-Muc: 25 * 53 = 1325
-I D: 25  53 = 0
-F D: 25  53 = 0.471698
-Mu: 25  53 = 25 
-P: 25 ^ 53 = 1.232595+74
+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/zettacode.files/arithmetic.integer/gambas.txt

@@ -1,30 +1,30 @@
-Pubc Sub M()
-  D , b A S
-  D c,  A I
+Public Sub Main()
+  Dim a, b As String
+  Dim c, d As Integer
 
-  P "E   ub,  b c:"
-  Iu , b
+  Print "Enter two integer numbers, separated by space:"
+  Input a, b
 
-  c = CI()
-   = CI(b)
+  c = CInt(a)
+  d = CInt(b)
 
-  P "Su: "  (c + )
-  P "Dffc:"  (c - )
-  P "Puc: "  (c * )
-  P "I: "  (c D )
-  P "R: "  (c M )
-  P "E: "  (c ^ )
+  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)
 
-E
+End
 
-Ouu:
+Output:
 
-E   ub,  b c:
+Enter two integer numbers, separated by space:
 8 1
-Su: 9
-Dffc:7
-Puc: 8
-I: 8
-R: 0
-E: 8
+Sum: 9
+Difference:7
+Product: 8
+Integer: 8
+Remainder: 0
+Exponentiation: 8
 

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

@@ -1,15 +1,15 @@
-u := fuco()
-  c , b, f
-  f := IuTU()
-  P(" =\")
-   := I(C(RL(f)))
-  P("b =\")
-  b := I(C(RL(f)))
-  D(Cc(S(), " + ", S(b), " = ", S( + b)))
-  D(Cc(S(), " - ", S(b), " = ", S( - b)))
-  D(Cc(S(), " * ", S(b), " = ", S( * b)))
-  D(Cc(S(), "  ", S(b), " = ", S(QuI(, b)))) #  0
-  D(Cc(S(), "  ", S(b), " = ", S(RI(, b)))) # 
-  D(Cc(S(), " ^ ", S(b), " = ", S( ^ b)))
-  CS(f)
-
+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/zettacode.files/arithmetic.integer/genie.txt

@@ -1,23 +1,23 @@
-N: U '':''   ''u'' f   bc  uc   0.43.92, Fbu 2019.
+Note: Using ''init:int'' and the ''return'' from the init block was introduced in release 0.43.92, February 2019.
 
-[d=4]
-*
-   AcI,  G
-   c c-.
-*
+[indent=4]
+/*
+   Arithmethic/Integer, in Genie
+   valac arithmethic-integer.gs
+*/
 
-:
-    : = 0
-    b: = 0
-    f .  2  b = .([2])
-    f .  1   = .([1])
+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])
 
-     @"+b: $ u  $b  $(+b)"
-     @"-b: $ u $b  $(-b)"
-     @"*b: $  $b  $(*b)"
-     @"b: $ b    $b qu   $(b)  (u   TRUNCATION)"
-     @"%b: $ b    $b   $(%b)  ( c f )"
+    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)"
 
-     "\G   cu     "
+    print "\nGenie does not include a raise to power operator"
 
-    u 0
+    return 0

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

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

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

@@ -1,66 +1,66 @@
-======
-ck m
+===int===
+package main
 
- "f"
+import "fmt"
 
-fuc () {
-     , b 
-    f.P("  : ")
-    f.Sc(, b)
-    f.Pf("% + % = %\", , b, +b)
-    f.Pf("% - % = %\", , b, -b)
-    f.Pf("% * % = %\", , b, *b)
-    f.Pf("%  % = %\", , b, b)   uc  0
-    f.Pf("% %% % = %\", , b, %b)     f 
-       
+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
 }
-{{u|E u}}
+{{out|Example run}}
 
-  : -5 3
+enter two integers: -5 3
 -5 + 3 = -2
 -5 - 3 = -8
 -5 * 3 = -15
--5  3 = -1
+-5 / 3 = -1
 -5 % 3 = -2
 
-===b.I===
-ck m
+===big.Int===
+package main
 
- (
-    "f"
-    "b"
+import (
+    "fmt"
+    "math/big"
 )
 
-fuc () {
-     , b, c b.I
-    f.P("  : ")
-    f.Sc(, b)
-    f.Pf("% + % = %\", , b, c.A(, b))
-    f.Pf("% - % = %\", , b, c.Sub(, b))
-    f.Pf("% * % = %\", , b, c.Mu(, b))
+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))
 
-     Qu, R fuc   G   :
-     qu uc  0,
-       -z        f .
-    f.Pf("% qu % = %\", , b, c.Qu(, b))
-    f.Pf("%  % = %\", , b, c.R(, 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))
 
-     D, M fuc  Euc :
-      u  =   b   -,
-      f  =   b,  u     * +  = .
-    f.Pf("%  % = %\", , b, c.D(, b))
-    f.Pf("%  % = %\", , b, c.M(, 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
 }
-{{u|E u}}
+{{out|Example run}}
 
-  : -5 3
+enter two integers: -5 3
 -5 + 3 = -2
 -5 - 3 = -8
 -5 * 3 = -15
--5 qu 3 = -1
--5  3 = -2
--5  3 = -2
--5  3 = 1
+-5 quo 3 = -1
+-5 rem 3 = -2
+-5 div 3 = -2
+-5 mod 3 = 1
 

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

@@ -1,18 +1,18 @@
-'''Su:'''
-df mc = { , b -
-     """
-        + b =        ${} + ${b} = ${ + b}
-        - b =        ${} - ${b} = ${ - b}
-        * b =        ${} * ${b} = ${ * b}
-         b =        ${}  ${b} = ${  b}   !!! C  f !
-()(  b) = ()(${}  ${b}) = ${()(  b)}              !!! Tuc  f  fc
- .(b) =  ${}.(${b}) = ${.(b)}              !!! B  f uc , cu  
-        % b =        ${} % ${b} = ${ % b}
+'''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}
 
-E    b c   G, :
-       ** b =       ${} ** ${b} = ${ ** b}
+Exponentiation is also a base arithmetic operation in Groovy, so:
+      a ** b =       ${a} ** ${b} = ${a ** b}
 """
 }
 
-'''T:'''
-mc(5,3)
+'''Test:'''
+arithmetic(5,3)

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

@@ -1,11 +1,11 @@
-ocdu T( , b )
-   ? "+b",  + b
-   ? "-b",  - b
-   ? "*b",  * b
-    T qu ' ,   u  I() fuc, c uc  .
-   ? "b", I(   b )
-    R:
-   ? "%b",  % b
-    E    b c 
-   ? "**b",  ** b
-   u
+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/zettacode.files/arithmetic.integer/haskell.txt

@@ -1,16 +1,16 @@
 
-m = do
-   - L :: IO I
-  b - L :: IO I
-  uSL $ " + b = " ++  ( + b)
-  uSL $ " - b = " ++  ( - b)
-  uSL $ " * b = " ++  ( * b)
-  uSL $ "    f b = " ++  ( ** b)
-  uSL $ "    f b = " ++  ( ^ b)
-  uSL $ "    f b = " ++  ( ^^ b)
-  uSL $ " `` b = "  ++  ( `` b)  -- uc   f
-  uSL $ " `` b = "  ++  ( `` b)  --    c 
-  uSL $ " `M` b = "  ++  ( `M` b)
-  uSL $ " `qu` b = " ++  ( `qu` b) -- uc  0
-  uSL $ " `` b = "  ++  ( `` b)  --    f 
-  uSL $ " `quR` b = "  ++  ( `quR` b)
+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)