zettacode 0.1.0 → 0.1.2

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

@@ -0,0 +1,293 @@
+{{works with|as|Raspberry Pi}}
+<syntaxhighlight lang="arm assembly">
+
+/* ARM assembly Raspberry PI  */
+/*  program arith.s   */
+/* Constantes    */
+.equ STDOUT, 1
+.equ WRITE,  4
+.equ EXIT,   1
+
+/***********************/
+/* Initialized data */
+/***********************/
+.data
+szMessError:      .asciz " Two numbers in command line please ! \n"       @ message
+szRetourLigne: .asciz "\n"
+szMessResult:  .asciz "Resultat "      @ message result
+sMessValeur:   .fill 12, 1, ' '
+                   .asciz "\n"
+szMessAddition: .asciz "addition :"
+szMessSoustraction: .asciz "soustraction :"
+szMessMultiplication: .asciz "multiplication :"
+szMessDivision: .asciz "division :"
+szMessReste: .asciz "reste :"
+   
+/***********************/				   
+/* No Initialized data */
+/***********************/
+.bss
+iValeur:  .skip  4     @ reserve 4 bytes in memory
+
+.text
+.global main 
+main:
+    push {fp,lr}                @ save des  2 registres
+    add fp,sp,#8                @ fp <- adresse début
+    ldr r0,[fp]                 @ recup number of parameter in command line
+    cmp r0,#3
+    blt error
+    ldr r0,[fp,#8]              @ adresse of 1er number
+    bl conversionAtoD
+    mov r3,r0
+    ldr r0,[fp,#12]             @ adresse of 2eme number
+    bl conversionAtoD
+    mov r4,r0
+    @ addition
+    add r0,r3,r4
+    ldr r1,iAdrsMessValeur      @ result in r0
+    bl conversion10S            @ call function with 2 parameter (r0,r1)
+    ldr r0,iAdrszMessResult
+    bl affichageMess            @ display message
+    ldr r0,iAdrszMessAddition
+    bl affichageMess            @ display message
+    ldr r0,iAdrsMessValeur
+    bl affichageMess            @ display message
+    @ soustraction
+    sub r0,r3,r4
+    ldr r1,=sMessValeur                 
+    bl conversion10S            @ call function with 2 parameter (r0,r1)
+    ldr r0,iAdrszMessResult
+    bl affichageMess            @ display message
+    ldr r0,iAdrszMessSoustraction
+    bl affichageMess            @ display message
+    ldr r0,iAdrsMessValeur
+    bl affichageMess            @ display message
+
+    @ multiplication
+    mul r0,r3,r4
+    ldr r1,=sMessValeur                 
+    bl conversion10S            @ call function with 2 parameter (r0,r1)
+    ldr r0,iAdrszMessResult
+    bl affichageMess            @ display message
+    ldr r0,iAdrszMessMultiplication
+    bl affichageMess            @ display message
+    ldr r0,iAdrsMessValeur
+    bl affichageMess            @ display message
+   
+    @ division 
+    mov r0,r3
+    mov r1,r4
+    bl division
+    mov r0,r2                   @ quotient
+    ldr r1,=sMessValeur                 
+    bl conversion10S            @ call function with 2 parameter (r0,r1)
+    ldr r0,iAdrszMessResult
+    bl affichageMess            @ display message
+    ldr r0,iAdrszMessDivision
+    bl affichageMess            @ display message
+    ldr r0,iAdrsMessValeur
+    bl affichageMess            @ display message
+
+    mov r0,r3                   @ remainder
+    ldr r1,=sMessValeur                 
+    bl conversion10S            @ call function with 2 parameter (r0,r1)
+    ldr r0,iAdrszMessResult
+    bl affichageMess            @ display message
+    ldr r0,iAdrszMessReste
+    bl affichageMess            @ display message
+    ldr r0,iAdrsMessValeur
+    bl affichageMess            @ display message
+ 
+    mov r0, #0                  @ return code
+    b 100f
+error:
+    ldr r0,iAdrszMessError
+    bl affichageMess            @ call function with 1 parameter (r0)
+    mov r0, #1                  @ return code
+100: /* end of  program */
+    mov r7, #EXIT               @ request to exit program
+    swi 0                       @ perform the system call
+iAdrsMessValeur: .int sMessValeur	
+iAdrszMessResult: .int szMessResult
+iAdrszMessError: .int szMessError
+iAdrszMessAddition: .int szMessAddition
+iAdrszMessSoustraction: .int szMessSoustraction
+iAdrszMessMultiplication: .int szMessMultiplication
+iAdrszMessDivision: .int szMessDivision
+iAdrszMessReste: .int szMessReste
+/******************************************************************/
+/*     affichage des messages   avec calcul longueur              */ 
+/******************************************************************/
+/* r0 contient l adresse du message */
+affichageMess:
+    push {fp,lr}        /* save des  2 registres */ 
+    push {r0,r1,r2,r7}  /* save des autres registres */
+    mov r2,#0           /* compteur longueur */
+1:                      /*calcul de la longueur */
+    ldrb r1,[r0,r2]     /* recup octet position debut + indice */
+    cmp r1,#0           /* si 0 c est fini */
+    beq 1f
+    add r2,r2,#1        /* sinon on ajoute 1 */
+    b 1b
+1:                      /* donc ici r2 contient la longueur du message */
+    mov r1,r0           /* adresse du message en r1 */
+    mov r0,#STDOUT      /* code pour écrire sur la sortie standard Linux */
+    mov r7, #WRITE      /* code de l appel systeme 'write' */
+    swi #0              /* appel systeme */
+    pop {r0,r1,r2,r7}   /* restaur des autres registres */
+    pop {fp,lr}         /* restaur des  2 registres */ 
+    bx lr	        /* retour procedure */	
+/***************************************************/
+/*   conversion registre en décimal   signé  */
+/***************************************************/
+/* r0 contient le registre   */
+/* r1 contient l adresse de la zone de conversion */
+conversion10S:
+    push {fp,lr}      /* save des  2 registres frame et retour */
+    push {r0-r5}      /* save autres registres  */
+    mov r2,r1         /* debut zone stockage */
+    mov r5,#'+'       /* par defaut le signe est + */
+    cmp r0,#0         /* nombre négatif ? */
+    movlt r5,#'-'     /* oui le signe est - */
+    mvnlt r0,r0       /* et inversion en valeur positive */
+    addlt r0,#1
+    mov r4,#10       /* longueur de la zone */
+1:                   /* debut de boucle de conversion */
+    bl divisionpar10 /* division  */
+    add r1,#48       /* ajout de 48 au reste pour conversion ascii */	
+    strb r1,[r2,r4]  /* stockage du byte en début de zone r5 + la position r4 */
+    sub r4,r4,#1     /* position précedente */
+    cmp r0,#0     
+    bne 1b	     /* boucle si quotient different de zéro */
+    strb r5,[r2,r4]  /* stockage du signe à la position courante */
+    subs r4,r4,#1    /* position précedente */
+    blt  100f        /* si r4 < 0  fin  */
+                     /* sinon il faut completer le debut de la zone avec des blancs */
+    mov r3,#' '      /* caractere espace */	
+2:
+    strb r3,[r2,r4]  /* stockage du byte  */
+    subs r4,r4,#1    /* position précedente */
+    bge 2b           /* boucle si r4 plus grand ou egal a zero */
+100:                 /* fin standard de la fonction  */
+    pop {r0-r5}      /*restaur des autres registres */
+    pop {fp,lr}      /* restaur des  2 registres frame et retour  */
+    bx lr   
+
+/***************************************************/
+/*   division par 10   signé                       */
+/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*  
+/* and   http://www.hackersdelight.org/            */
+/***************************************************/
+/* r0 contient le dividende   */
+/* r0 retourne le quotient */	
+/* r1 retourne le reste  */
+divisionpar10:	
+  /* r0 contains the argument to be divided by 10 */
+   push {r2-r4}   /* save autres registres  */
+   mov r4,r0 
+   ldr r3, .Ls_magic_number_10 /* r1 <- magic_number */
+   smull r1, r2, r3, r0   /* r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) */
+   mov r2, r2, ASR #2     /* r2 <- r2 >> 2 */
+   mov r1, r0, LSR #31    /* r1 <- r0 >> 31 */
+   add r0, r2, r1         /* r0 <- r2 + r1 */
+   add r2,r0,r0, lsl #2   /* r2 <- r0 * 5 */
+   sub r1,r4,r2, lsl #1   /* r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10) */
+   pop {r2-r4}
+   bx lr                  /* leave function */
+   .align 4
+.Ls_magic_number_10: .word 0x66666667
+/******************************************************************/
+/*     Conversion d une chaine en nombre stocké dans un registre  */ 
+/******************************************************************/
+/* r0 contient l adresse de la zone terminée par 0 ou 0A */
+conversionAtoD:
+    push {fp,lr}      /* save des  2 registres */ 
+    push {r1-r7}      /* save des autres registres */
+    mov r1,#0
+    mov r2,#10        /* facteur */
+    mov r3,#0         /* compteur */
+    mov r4,r0         /* save de l adresse dans r4 */
+    mov r6,#0         /* signe positif par defaut */
+    mov r0,#0         /* initialisation à 0 */ 
+1:                    /* boucle d élimination des blancs du debut */
+    ldrb r5,[r4,r3]   /* chargement dans r5 de l octet situé au debut + la position */
+    cmp r5,#0         /* fin de chaine -> fin routine */
+    beq 100f
+    cmp r5,#0x0A      /* fin de chaine -> fin routine */
+    beq 100f
+    cmp r5,#' '       /* blanc au début */
+    bne 1f            /* non on continue */
+    add r3,r3,#1      /* oui on boucle en avançant d un octet */
+    b 1b
+1:
+    cmp r5,#'-'       /* premier caracteres est -    */
+    moveq r6,#1       /* maj du registre r6 avec 1 */
+    beq 3f            /* puis on avance à la position suivante */
+2:                    /* debut de boucle de traitement des chiffres */
+    cmp r5,#'0'       /* caractere n est pas un chiffre */
+    blt 3f
+    cmp r5,#'9'       /* caractere n est pas un chiffre */
+    bgt 3f
+                      /* caractère est un chiffre */
+    sub r5,#48
+    ldr r1,iMaxi      /*verifier le dépassement du registre  */  
+    cmp r0,r1
+    bgt 99f
+    mul r0,r2,r0     /* multiplier par facteur */
+    add r0,r5        /* ajout à r0 */
+3:
+    add r3,r3,#1     /* avance à la position suivante */
+    ldrb r5,[r4,r3]  /* chargement de l octet */
+    cmp r5,#0        /* fin de chaine -> fin routine */
+    beq 4f
+    cmp r5,#10       /* fin de chaine -> fin routine */
+    beq 4f
+    b 2b             /* boucler */ 
+4:
+    cmp r6,#1        /* test du registre r6 pour le signe */
+    bne 100f
+    mov r1,#-1
+    mul r0,r1,r0    /* si negatif, on multiplie par -1 */
+    b 100f
+99:                 /* erreur de dépassement */
+    ldr r1,=szMessErrDep
+    bl   afficheerreur 
+    mov r0,#0       /* en cas d erreur on retourne toujours zero */
+100:
+    pop {r1-r7}     /* restaur des autres registres */
+    pop {fp,lr}     /* restaur des  2 registres */ 
+    bx lr           /* retour procedure */	
+/* constante programme */	
+iMaxi: .int 1073741824	
+szMessErrDep:  .asciz  "Nombre trop grand : dépassement de capacite de 32 bits. :\n"
+.align 4
+/*=============================================*/
+/* division entiere non signée                */
+/*============================================*/
+division:
+    /* r0 contains N */
+    /* r1 contains D */
+    /* r2 contains Q */
+    /* r3 contains R */
+    push {r4, lr}
+    mov r2, #0              /* r2 ? 0 */
+    mov r3, #0              /* r3 ? 0 */
+    mov r4, #32             /* r4 ? 32 */
+    b 2f
+1:
+    movs r0, r0, LSL #1    /* r0 ? r0 << 1 updating cpsr (sets C if 31st bit of r0 was 1) */
+    adc r3, r3, r3         /* r3 ? r3 + r3 + C. This is equivalent to r3 ? (r3 << 1) + C */
+ 
+    cmp r3, r1             /* compute r3 - r1 and update cpsr */
+    subhs r3, r3, r1       /* if r3 >= r1 (C=1) then r3 ? r3 - r1 */
+    adc r2, r2, r2         /* r2 ? r2 + r2 + C. This is equivalent to r2 ? (r2 << 1) + C */
+2:
+    subs r4, r4, #1        /* r4 ? r4 - 1 */
+    bpl 1b                 /* if r4 >= 0 (N=0) then branch to .Lloop1 */
+ 
+    pop {r4, lr}
+    bx lr	
+
+
+

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

@@ -0,0 +1,10 @@
+
+a: to :integer input "give me the first number  : "
+b: to :integer input "give me the second number : "
+
+print [a "+" b "=" a+b]
+print [a "-" b "=" a-b]
+print [a "*" b "=" a*b]
+print [a "/" b "=" a/b]
+print [a "%" b "=" a%b]
+print [a "^" b "=" a^b]

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

@@ -0,0 +1,17 @@
+int a = -12;
+int b = 7;
+
+int suma = a + b;
+int resta = a - b;
+int producto = a * b;
+real division = a / b;
+int resto = a % b;
+int expo = a ** b;
+
+write("Siendo dos enteros a = -12 y b = 7");
+write("       suma de a + b = ", suma);
+write("      resta de a - b = ", resta);
+write("   producto de a * b = ", producto);
+write("   división de a / b = ", division);
+write("   resto de a mod  b = ", resto);
+write("exponenciación a ^ b = ", expo);

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

@@ -0,0 +1,20 @@
+The quotient rounds towards 0 if both inputs are integers or towards negative infinity if either input is floating point. The sign of the remainder is always the same as the sign of the first parameter (dividend).
+Gui, Add, Edit, va, 5
+Gui, Add, Edit, vb, -3
+Gui, Add, Button, Default, Compute
+Gui, Show
+Return
+
+ButtonCompute:
+  Gui, Submit
+  MsgBox,%
+  (Join`s"`n"
+   a "+" b " = " a+b
+   a "-" b " = " a-b
+   a "*" b " = " a*b
+   a "//" b " = " a//b " remainder " Mod(a,b)
+   a "**" b " = " a**b
+  )
+; fallthrough
+GuiClose:
+  ExitApp

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

@@ -0,0 +1,13 @@
+Method "arithmetic demo_,_" is 
+[
+    a : integer,
+    b : integer
+|
+    Print: “a + b”;
+    Print: “a - b”;
+    Print: “a × b”; // or a * b
+    Print: “a ÷ b”; // or a / b, rounds toward negative infinity
+    Print: “a mod b”; // sign matches second argument
+    Print: “a ^ b”;
+];
+

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

@@ -0,0 +1,12 @@
+/^[ \t]*-?[0-9]+[ \t]+-?[0-9]+[ \t]*$/ {
+	print "add:", $1 + $2
+	print "sub:", $1 - $2
+	print "mul:", $1 * $2
+	print "div:", int($1 / $2) # truncates toward zero
+	print "mod:", $1 % $2      # same sign as first operand
+	print "exp:", $1 ^ $2
+	exit }
+
+For division and modulus, Awk should act like C.
+
+'''Exponentiation's note:''' With [[nawk]] or [[gawk]], <code>$1 ** $2</code> acts like <code>$1 ^ $2</code>. With [[mawk]], <code>$1 ** $2</code> is a syntax error. Nawk allows <code>**</code>, but its manual page only has <code>^</code>. Gawk's manual warns, ''"The POSIX standard only specifies the use of `^' for exponentiation. For maximum portability, do not use the `**' operator."''

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

@@ -0,0 +1,56 @@
+==={{header|Applesoft BASIC}}===
+Same code as [[#Commodore_BASIC|Commodore BASIC]]
+==={{header|BaCon}}===
+' Arthimetic/Integer
+DECLARE a%, b%
+INPUT "Enter integer A: ", a%
+INPUT "Enter integer B: ", b%
+PRINT
+
+PRINT a%, " + ", b%, "     is ", a% + b%
+PRINT a%, " - ", b%, "     is ", a% - b%
+PRINT a%, " * ", b%, "     is ", a% * b%
+PRINT a%, " / ", b%, "     is ", a% / b%, ", trucation toward zero"
+PRINT "MOD(", a%, ", ", b%, ") is ", MOD(a%, b%), ", same sign as first operand"
+PRINT "POW(", a%, ", ", b%, ") is ", INT(POW(a%, b%))
+
+==={{header|Commodore BASIC}}===
+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%;"/";B%;"=";INT(A%/B%)
+70 PRINT "REMAINDER OR MODULO:";A%;"%";B%;"=";A%-INT(A%/B%)*B%
+80 PRINT "POWER:";A%;"^";B%;"=";A%^B%
+
+==={{header|True BASIC}}===
+
+! RosettaCode: Integer Arithmetic
+! True BASIC v6.007
+! Translated from BaCon example.
+PROGRAM Integer_Arithmetic
+	INPUT PROMPT "Enter integer A: ": a
+	INPUT PROMPT "Enter integer B: ": b
+	PRINT
+	PRINT a;" + ";b;" is ";a+b
+	PRINT a;" - ";b;" is ";a-b
+	PRINT a;" * ";b;" is ";a*b
+	PRINT a;" / ";b;" is ";INT(a/b);
+	PRINT "MOD(";a;", ";b;") is "; MOD(a,b)
+	PRINT "POW(";a;", ";b;") is ";INT(a^b)
+	GET KEY done
+END
+
+==={{header|QBasic}}===
+{{works with|QuickBasic|4.5}}
+function math(a!, b!)
+	print a + b
+	print a - b
+	print a * b
+	print a / b
+	print a mod b
+end function
+Truncate towards: 0
+
+Remainder sign matches: first operand

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

@@ -0,0 +1,11 @@
+
+input "enter a number ?", a
+input "enter another number ?", b
+
+print "addition " + a + " + " + b + " = " + (a + b)
+print "subtraction " + a + " - " + b + " = " + (a - b)
+print "multiplication " + a + " * " + b + " = " + (a * b)
+print "integer division " + a + " \ " + b + " = " + (a \ b)
+print "remainder or modulo " + a + " % " + b + " = " + (a % b)
+print "power " + a + " ^ " + b + " = " + (a ^ b)
+

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

@@ -0,0 +1,7 @@
+{{works with|Windows 7| or later, haven't checked earlier versions}}
+
+set /p equation=
+set /a result=%equation%
+echo %result%
+pause
+

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

@@ -0,0 +1,9 @@
+      INPUT "Enter the first integer: " first%
+      INPUT "Enter the second integer: " second%
+      
+      PRINT "The sum is " ; first% + second%
+      PRINT "The difference is " ; first% - second%
+      PRINT "The product is " ; first% * second%
+      PRINT "The integer quotient is " ; first% DIV second% " (rounds towards 0)"
+      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/files.zettacode/arithmetic.integer/bc.txt

@@ -0,0 +1,8 @@
+define f(a, b) {
+	"add: "; a + b
+	"sub: "; a - b
+	"mul: "; a * b
+	"div: "; a / b  /* truncates toward zero */
+	"mod: "; a % b  /* same sign as first operand */
+	"pow: "; a ^ b
+}

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

@@ -0,0 +1,6 @@
+&&00p"=A",,:."=B ",,,00g.55+,v
+        v,+55.+g00:,,,,"A+B="<
+        >"=B-A",,,,:00g-.55+,v
+        v,+55.*g00:,,,,"A*B="<
+        >"=B/A",,,,:00g/.55+,v
+         @,+55.%g00,,,,"A%B="<

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

@@ -0,0 +1,22 @@
+•Out "Enter number 1: "
+a ← •BQN •GetLine @
+•Out "Enter number 2: "
+b ← •BQN •GetLine @
+
+•Show a + b
+•Show a - b
+•Show a × b
+•Show a ÷ b
+•Show b | a
+•Show a ⋆ b
+Enter number 1:
+12
+Enter number 2:
+2
+14
+10
+24
+6
+0
+144
+

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

@@ -0,0 +1,19 @@
+The remainder returned by mod is non-negative. Furthermore, <code>div$(!a.!d)*!d+mod$(!a.!d):!a</code> for all integer <code>!a</code> and <code>!d</code>, <code>!d:~0</code>.
+  ( enter
+  =     put$"Enter two integer numbers, separated by space:"
+      &amp; get':(~/#?k_~/#?m|quit:?k)
+    |     out
+        $ "You must enter two integer numbers! Enter \"quit\" if you don't know how to do that."
+      &amp; !enter
+  )
+&amp; !enter
+&amp; !k:~quit
+&amp; out$("You entered" !k and !m ". Now look:")
+&amp; out$("Sum:" !k+!m)
+&amp; out$("Difference:" !k+-1*!m)
+&amp; out$("Product:" !k*!m)
+&amp; out$("Integer division:" div$(!k.!m))
+&amp; out$("Remainder:" mod$(!k.!m))
+&amp; out$("Exponentiation:" !k^!m)
+&amp; done;
+

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

@@ -0,0 +1,8 @@
+Inspired by the second VBScript version.
+x = ask("First number: ").to_i
+y = ask("Second number: ").to_i
+
+#Division uses floating point
+#Remainder uses sign of right hand side
+[:+ :- :* :/ :% :^].each { op |
+  p "#{x} #{op} #{y} = #{x.call_method op, y}"

data/files.zettacode/arithmetic.integer/c++.txt

@@ -0,0 +1,12 @@
+#include <iostream>
+
+int main()
+{
+  int a, b;
+  std::cin >> a >> b;
+  std::cout << "a+b = " << a+b << "\n";
+  std::cout << "a-b = " << a-b << "\n";
+  std::cout << "a*b = " << a*b << "\n";
+  std::cout << "a/b = " << a/b << ", remainder " << a%b << "\n";
+  return 0;
+}

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

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+  int a, b;
+  if (argc < 3) exit(1);
+  b = atoi(argv[--argc]);
+  if (b == 0) exit(2);
+  a = atoi(argv[--argc]);
+  printf("a+b = %d\n", a+b);
+  printf("a-b = %d\n", a-b);
+  printf("a*b = %d\n", a*b);
+  printf("a/b = %d\n", a/b); /* truncates towards 0 (in C99) */
+  printf("a%%b = %d\n", a%b); /* same sign as first operand (in C99) */
+  return 0;
+}

data/files.zettacode/arithmetic.integer/c_sharp|c#.txt

@@ -0,0 +1,17 @@
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        int a = Convert.ToInt32(args[0]);
+        int b = Convert.ToInt32(args[1]);
+
+        Console.WriteLine("{0} + {1} = {2}", a, b, a + b);
+        Console.WriteLine("{0} - {1} = {2}", a, b, a - b);
+        Console.WriteLine("{0} * {1} = {2}", a, b, a * b);
+        Console.WriteLine("{0} / {1} = {2}", a, b, a / b); // truncates towards 0
+        Console.WriteLine("{0} % {1} = {2}", a, b, a % b); // matches sign of first operand
+        Console.WriteLine("{0} to the power of {1} = {2}", a, b, Math.Pow(a, b));
+    }
+}

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

@@ -0,0 +1,37 @@
+
+Number Soup.
+
+Only reads single values.
+
+Ingredients.
+1 g Numbers
+3 g Water
+5 g Soup
+
+Method.
+Take Numbers from refrigerator.
+Take Soup from refrigerator.
+Put Numbers into 1st mixing bowl.
+Add Soup into the 1st mixing bowl.
+Pour contents of the 1st mixing bowl into 1st baking dish.
+Clean 1st mixing bowl.
+Put Numbers into 1st mixing bowl.
+Remove Soup from 1st mixing bowl.
+Pour contents of the 1st mixing bowl into 2nd baking dish.
+Clean 1st mixing bowl.
+Put Numbers into 1st mixing bowl.
+Combine Soup into 1st mixing bowl.
+Pour contents of the 1st mixing bowl into 3rd baking dish.
+Clean 1st mixing bowl.
+Put Numbers into 1st mixing bowl.
+Divide Soup into 1st mixing bowl.
+Pour contents of the 1st mixing bowl into 4th baking dish.
+Clean 1st mixing bowl.
+Put Water into 1st mixing bowl.
+Verb the Soup.
+Combine Numbers into 1st mixing bowl.
+Verb the Soup until verbed.
+Pour contents of the 1st mixing bowl into 5th baking dish.
+Clean 1st mixing bowl.
+
+Serves 5.

data/files.zettacode/arithmetic.integer/clipper.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.zettacode/arithmetic.integer/clojure.txt

@@ -0,0 +1,18 @@
+(defn myfunc []
+  (println "Enter x and y")
+  (let [x (read), y (read)]
+    (doseq [op '(+ - * / Math/pow rem)]
+      (let [exp (list op x y)]
+	(printf "%s=%s\n" exp (eval exp))))))
+
+user=> (myfunc)
+Enter x and y
+3
+6
+(+ 3 6)=9
+(- 3 6)=-3
+(* 3 6)=18
+(/ 3 6)=1/2
+(Math/pow 3 6)=729.0
+(rem 3 6)=3
+nil