zettacode 0.1.0 → 0.1.1

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

@@ -1,9 +1,9 @@
 
-'  Numb 1: '  c 0 f  
-'  Nub 2: '  c 0 f  
+'  Number 1: ' print expect 0 prefer as x
+'  Number 2: ' print expect 0 prefer as y
 
-  + "       u: %\" 
-  - "ffc: %\" 
-  * "   uc: %\" 
-   "  qu: %\" 
-  % " : %\" 
+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/zettacode.files/arithmetic.integer/rebol.txt

@@ -1,51 +1,51 @@
 REBOL [
-	T: "I"
-	URL: :c.AcI
+	Title: "Integer"
+	URL: http://rosettacode.org/wiki/Arithmetic/Integer
 ]
 
-: -  "P    ,   []: "
-: -  "P   : "
- ""
-
- ["Su:"   + ]
- ["Dffc:"   - ]
- ["Puc:"  * ]
-
- ["I qu (cc)                          :"  -   ]
- ["I qu ( f z)                    :"  u   ]
- ["I qu ( u   )  :"  u   ]
- ["I qu ( u  z)         :"  uf-   ]
- ["I qu (u   c)       :"  uf   ]
- ["I qu (u   c)       :"  uc   ]
- ["I qu ( u   c):"  uf-c   ]
-
- ["R:"  :   ]
-
- REBOL u f  f f  . T  
- cc u --   f  u. Tf 
- f  c, I u  u  f 
- ("? ") f      u f  '
- c    f b. T  u f , c  I '
-   u  cfc u . T f u  
- fuc  u uc.
-
-c?: fuc [ b][(? ) = ? b]
-
-u: c []
-f c?   [ u "f"]
-f c?   [ u "c"]
-
- Yu c u b     f  , 
- I u  "c"     b u b  
-  f  u .
-
- [
-	"R  c:" 
-	c ? u [
-		0 [""]
-		1 [u1]
-		2 ["b"]
+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"]
 	] 
 ]
 
- ["E:"  ** ]
+print ["Exponentiation:" x ** y]

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

@@ -1,11 +1,11 @@
-T   u, b   b   c. F    f uu.
+There is no input, variables have to be set in code. Format is there only for output.
 
-  = -17
- b = 4
-c "+b = ".f(+b,"%1")
-c "-b = ".f(-b,"%1")
-c "*b = ".f(*b,"%1")
-c " DIV b = ".f(f(b),"%1")
-c " MOD b = ".f(  b,"%1")
-c "^b = ".f((,b),"%1")
+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/zettacode.files/arithmetic.integer/rescript.txt

@@ -1,15 +1,15 @@
 
-  = _of_(S.v[2])
- b = _f_(S.[3])
+let a = int_of_string(Sys.argv[2])
+let b = int_of_string(Sys.argv[3])
 
- u =  + b
- ffc =  - b
- uc =  * b
-  =   b
-  = (, b)
+let sum = a + b
+let difference = a - b
+let product = a * b
+let division = a / b
+let remainder = mod(a, b)
 
-J.(" + b = " ++ _f_(u))
-J.(" - b = " ++ _f_(ffc))
-J.(" * b = " ++ _f_(uc))
-J.("  b = " ++ _f_())
-J.(" % b = " ++ _f_())
+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/zettacode.files/arithmetic.integer/retro.txt

@@ -1,10 +1,10 @@
-R' c fuc  b    [[F]]. T     f   f F.
+Retro's arithmetic functions are based on those in [[Forth]]. The example is an adaption of the one from Forth.
  
-:mc (b-)
-         '\_______=_% :u
-  u        '\b_______=_% :u
-  u- + '\_+_b___=_% :u
-  u- - '\_-_b___=_% :u
-  u- * '\_*_b___=_% :u
-         '\__b___=_% :u
-             '\__b_=_%\" :u 
+: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/zettacode.files/arithmetic.integer/rexx.txt

@@ -1,47 +1,47 @@
-A  uc uc    b (u   c     b),
-b ub   f  c. b (T REXX fu  b '''9''' b c .)
+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.)
 
-F   uc  f  ub,  u  u    ub  c b   
-b  cu ub f c  b (    b,   b '''20''' b c ).
-*REXX om ob wo  fom  C.L. ( om)  d om oo.*
-uc  20                                *#  u  20 fc .*
-    .                                  *b       C.L.  *
+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.  */
 
-    \(,'W') | \(,'W')   *b   X    Y   u b . *
-   "─────E   u  ( b b):"
-   u   .                               *cc   f c .*
-     **
-                                                 * [↓]  f   DO   c.  *
-      j=1  f 2                               *  A    B,     B    A.*
-     c  ''          ,  "+",   +
-     c  'ubc'       ,  "-",   -
-     c  'uc'    ,  "*",   *
-     c  '  '     ,  "%",   %,  '    [u ]'
-     c  ' '     ,  "",   
-     c  ' ',  "",  , '    [ f 1 ]'
-     c  ''             ,  "**",  **
+  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
 
-      u                         *   u  f *
-     f j==1    c('═', 79)           *  fc f  1 u. *
-        *j*
-                                             *c  f  ,  '  . *
-*──────────────────────────────────────────────────────────────────────────────────────*
-:   c,,#,?    (c,25)' '    c(,4)    " ───► "  #  ?   u
-{{u|uu|=b  u  u f: b b  4 b -17 }}
+     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>}}
 
-                   4  +   -17  ───►  -13
-              ubc  4  -   -17  ───►  21
-           uc  4  *   -17  ───►  -68
-                4  %   -17  ───►  0     [u ]
-               4     -17  ───►  -0.23529411764705882353
-          4    -17  ───►  4     [ f 1 ]
-                      4  **  -17  ───►  5.8207660913467407227E-11
+                 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
 ═══════════════════════════════════════════════════════════════════════════════
-                   -17  +   4  ───►  -13
-              ubc  -17  -   4  ───►  -21
-           uc  -17  *   4  ───►  -68
-                -17  %   4  ───►  -4     [u ]
-               -17     4  ───►  -4.25
-          -17    4  ───►  -1     [ f 1 ]
-                      -17  **  4  ───►  83521
+                 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/zettacode.files/arithmetic.integer/ring.txt

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

@@ -1,13 +1,13 @@
 
-u  "E ub 1:"
- ""  "u"
-u  "E ub 2:"
- "b"  "u"
+input string "Enter number 1:"
+set "a" to "input"
+input string "Enter number 2:"
+set "b" to "input"
 
-[ "Su: ('' + 'b')"
-[ "Dffc: ('' - 'b')"
-[ "Puc: ('' * 'b')"
-[ "I Qu: (''  'b')"
-[ "R: ('' % 'b')"
-[ "E: (''^'b')"
+[ "Sum: ('a' + 'b')"
+[ "Difference: ('a' - 'b')"
+[ "Product: ('a' * 'b')"
+[ "Integer Quotient: ('a' / 'b')"
+[ "Remainder: ('a' % 'b')"
+[ "Exponentiation: ('a'^'b')"
 

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

@@ -1,12 +1,12 @@
 
-u 'E  d '
- = ._  #  cc , u =I()
- = ._
+puts 'Enter x and y'
+x = gets.to_i  # to check errors, use x=Integer(gets)
+y = gets.to_i
 
-u "Su: #{+}",
-     "Dffc: #{-}",
-     "Puc: #{*}",
-     "Qu: #{}",       # uc   f
-     "Qu: #{.f()}", # f
-     "R: #{%}",      #    c 
-     "E: #{**}"
+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/zettacode.files/arithmetic.integer/run_basic.txt

@@ -1,9 +1,9 @@
-u "1 : " 1
-u "2 : " 2
+input "1st integer: "; i1
+input "2nd integer: "; i2
  
- "      Su" 1 + 2
- "     Dff" 1 - 2
- "  Puc" 1 * 2
-f 2 0   "  Qu " ( 1  2)   "C  b z."
- "R" 1 MOD 2
- "1    f 2" 1 ^ 2
+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/zettacode.files/arithmetic.integer/rust.txt

@@ -1,15 +1,15 @@
 
-N   c c b u   [:.u-. Ru ]     u c u.
-u d::v
+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;
 
-f () {
-     : Vc_ = ::().cc()
-      = [1].::32().u()
-     b = [2].::32().u()
+fn main() {
+    let args: Vec<_> = env::args().collect();
+    let a = args[1].parse::<i32>().unwrap();
+    let b = args[2].parse::<i32>().unwrap();
 
-    !("u:              {}",  + b)
-    !("ffc:       {}",  - b)
-    !("uc:          {}",  * b)
-    !(" qu: {}",   b)  uc  z
-    !(":        {}",  % b)     f 
+    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/zettacode.files/arithmetic.integer/sass-scss.txt

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

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

@@ -1,9 +1,9 @@
-v  = Coo.dI
- b = C.I
+val a = Console.readInt
+val b = Console.readInt
  
- u =  + b    cu    u  cfu  S cc
-(" + b = " + u)
-(" - b = " + ( - b))
-(" * b = " + ( * b))
-("qu f   b = " + (  b))  uc  0
-(" f   b = " + ( % b))     f 
+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/zettacode.files/arithmetic.integer/scheme.txt

@@ -1,27 +1,27 @@
 
-(df (mc  )
-  (f-c (b ()
-              (  (   ))
-              ( " = ")
-              ( (( )  ))
-              ())
-            '(+ - *  qu  u   c c)))
+(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)))
            
-(c 8 12)
-qu - uc  0
- -    f 
-u -    c 
+(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) = 23
- (qu 8 12) = 0
- ( 8 12) = 8
- (u 8 12) = 8
- ( 8 12) = 12
- ( 8 12) = 8
- (c 8 12) = 4
- (c 8 12) = 24
+ (+ 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/zettacode.files/arithmetic.integer/seed7.txt

@@ -1,20 +1,20 @@
-$ cud "d7_05.7"
+$ include "seed7_05.s7i";
 
-c c:   fuc
-  c
-     :   0
-     : b  0
-  b
-    (" = ")
-    ()
-    ("b = ")
-    (b)
+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);
  
-    (" + b = "   + b)
-    (" - b = "   - b)
-    (" * b = "   * b)
-    ("  b = "    b)    # Ru  z
-    ("  b = "    b)    # S f  f 
-    ("  b = "    b)  # Ru   f
-    ("  b = "    b)    # S f  c 
-   fuc
+    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/zettacode.files/arithmetic.integer/sensetalk.txt

@@ -1,12 +1,12 @@
-k "E  f umb:"
-u   ub1
+ask "Enter the first number:"
+put it into number1
 
- "E  c ub:"
-u   ub2
+ask "Enter the second number:"
+put it into number2
 
-u "Su: "  ub1 u ub2
-u "Dffc: "  ub1 u ub2
-u "Puc: "  ub1 u b ub2
-u "I qu: "  ub1  ub2 -- Ru  0
-u "R: "  ub1  ub2
-u "E: "  ub1    f ub2
+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/zettacode.files/arithmetic.integer/sidef.txt

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

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

@@ -1,9 +1,9 @@
-[| : :b |
-f: ( + b) S.
-f: ( - b) S.
-f: ( * b) S.
-f: (  b) S.
-f: (  b) S.
-f: ( \\ b) S.
+[| :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.
 
-] T: {I F: (qu: 'E : '). I F: (qu: 'E b: ')}.
+] applyTo: {Integer readFrom: (query: 'Enter a: '). Integer readFrom: (query: 'Enter b: ')}.