Data commit

Task/Arithmetic-Integer/00-META.yaml

@@ -0,0 +1,7 @@
+---
+category:
+- Arithmetic operations
+- Arithmetic
+- Simple
+from: http://rosettacode.org/wiki/Arithmetic/Integer
+note: Basic language learning

Task/Arithmetic-Integer/00-TASK.txt

@@ -0,0 +1,20 @@
+{{basic data operation}} 
+;Task:
+Get two integers from the user,    and then (for those two integers), display their:
+::::*   sum 
+::::*   difference 
+::::*   product 
+::::*   integer quotient
+::::*   remainder 
+::::*   exponentiation   (if the operator exists) 
+
+<br>
+Don't include error handling. 
+
+For quotient, indicate how it rounds &nbsp; (e.g. towards zero, towards negative infinity, etc.). 
+
+For remainder, indicate whether its sign matches the sign of the first operand or of the second operand, if they are different.
+<br><br>
+
+Bonus: Include an example of the integer `divmod` operator. For example: as in [[#Haskell]], [[#Python]] and [[#ALGOL 68]]
+

Task/Arithmetic-Integer/0815/arithmetic-integer.0815

@@ -0,0 +1,13 @@
+|~>|~#:end:>
+<:61:x<:3d:=<:20:$==$~$=${~>%<:2c:~$<:20:~$
+<:62:x<:3d:=<:20:$==$~$=${~>%<:a:~$$
+<:61:x<:2b:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~+%<:a:~$
+<:61:x<:2d:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~-%<:a:~$
+<:61:x<:2a:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~*%<:a:~$
+<:61:x<:2f:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~/%<:a:~$
+<:61:x<:25:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~/=%<:a:~$
+{~>>{x<:1:-^:u:
+<:61:x<:5e:=<:20:$==$~$$=$<:62:x<:3D:=<:20:$==$~$=${{~%#:end:
+}:u:=>{x{=>~*>{x<:2:-#:ter:
+}:ml:x->{x{=>~*>{x<:1:-#:ter:^:ml:
+}:ter:<:61:x<:5e:=<:20:$==$~$$=$<:62:x<:3D:=<:20:$==$~$=${{~%

Task/Arithmetic-Integer/11l/arithmetic-integer.11l

@@ -0,0 +1,9 @@
+V a = Int(input())
+V b = Int(input())
+
+print(‘a + b = ’(a + b))
+print(‘a - b = ’(a - b))
+print(‘a * b = ’(a * b))
+print(‘a / b = ’(a I/ b))
+print(‘a % b = ’(a % b))
+print(‘a ^ b = ’(a ^ b))

Task/Arithmetic-Integer/360-Assembly/arithmetic-integer.360

@@ -0,0 +1,39 @@
+*        Arithmetic/Integer        04/09/2015
+ARITHINT CSECT
+         USING  ARITHINT,R12
+         LR     R12,R15
+ADD      L      R1,A
+         A      R1,B               r1=a+b
+         XDECO  R1,BUF
+         MVI    BUF,C'+'
+         XPRNT  BUF,12
+SUB      L      R1,A
+         S      R1,B               r1=a-b
+         XDECO  R1,BUF
+         MVI    BUF,C'-'
+         XPRNT  BUF,12
+MUL      L      R1,A
+         M      R0,B               r0r1=a*b
+         XDECO  R1,BUF             so r1 has the lower part
+         MVI    BUF,C'*'
+         XPRNT  BUF,12
+DIV      L      R0,A
+         SRDA   R0,32              to shift the sign
+         D      R0,B               r1=a/b and r0 has the remainder
+         XDECO  R1,BUF             so r1 has quotient
+         MVI    BUF,C'/'
+         XPRNT  BUF,12
+MOD      L      R0,A
+         SRDA   R0,32              to shift the sign
+         D      R0,B               r1=a/b and r0 has the remainder
+         XDECO  R0,BUF             so r0 has the remainder
+         MVI    BUF,C'R'
+         XPRNT  BUF,12
+RETURN   XR     R15,R15
+         BR     R14
+         CNOP   0,4
+A        DC     F'53'
+B        DC     F'11'
+BUF      DC     CL12' '
+         YREGS
+         END    ARITHINT

Task/Arithmetic-Integer/6502-Assembly/arithmetic-integer.6502

@@ -0,0 +1,48 @@
+Arithmetic:	PHA			;push accumulator and X register onto stack
+		TXA
+		PHA
+		JSR GetUserInput	;routine not implemented
+		;two integers now in memory locations A and B
+		;addition
+		LDA A
+		CLC
+		ADC B
+		JSR DisplayAddition	;routine not implemented
+
+		;subtraction
+		LDA A
+		SEC
+		SBC B
+		JSR DisplaySubtraction	;routine not implemented
+
+		;multiplication - overflow not handled
+		LDA A
+		LDX B
+Multiply:	CLC
+		ADC A
+		DEX
+		BNE Multiply
+		JSR DisplayMultiply	;routine not implemented
+
+		;division	- rounds up
+		LDA A
+		LDX #0
+		SEC
+Divide:		INX
+		SBC B
+		BCS Divide
+		TXA			;get result into accumulator
+		JSR DisplayDivide	;routine not implemented
+
+		;modulus
+		LDA A
+		SEC
+Modulus:	SBC B
+		BCS Modulus
+		ADC B
+		JSR DisplayModulus	;routine not implemented
+
+		PLA			;restore accumulator and X register from stack
+		TAX
+		PLA
+		RTS			;return from subroutine

Task/Arithmetic-Integer/68000-Assembly/arithmetic-integer-1.68000

@@ -0,0 +1,12 @@
+ADD.L D0,D1 ; add two numbers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+SUB.L D1,D0 ; subtract D1 from D0
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+MULU D0,D1  ; multiply two unsigned numbers. Use MULS for signed numbers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+DIVU D1,D0  ; Divide D0 by D1. Use DIVS for signed numbers. Upper two bytes of D0 are the remainder, lower two are the integer quotient.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+MODULUS:
+DIVU D1,D0
+SWAP D0     ;swap the order of the 16-bit halves of D0.
+RTS

Task/Arithmetic-Integer/68000-Assembly/arithmetic-integer-2.68000

@@ -0,0 +1,9 @@
+Exponent:
+;raises D0 to the D1 power. No overflow protection.
+MOVE.L D0,D2
+SUBQ.L #1,D1
+loop_exponent:
+MULU D0,D2
+DBRA D1,loop_exponent
+;output is in D2
+RTS

Task/Arithmetic-Integer/AArch64-Assembly/arithmetic-integer.aarch64

@@ -0,0 +1,125 @@
+/* ARM assembly AARCH64 Raspberry PI 3B */
+/*  program arith64.s   */
+
+/*******************************************/
+/* Constantes file                         */
+/*******************************************/
+/* for this file see task include a file in language AArch64 assembly*/
+.include "../includeConstantesARM64.inc"
+
+/***********************/
+/* Initialized data */
+/***********************/
+.data
+szMessError:          .asciz " Two numbers in command line please ! \n"       // message
+szRetourLigne:        .asciz "\n"
+szMessResult:         .asciz "resultat : @ \n"      // message result
+sMessValeur:          .fill 12, 1, ' '
+                      .asciz "\n"
+szMessAddition:       .asciz "Addition "
+szMessSoustraction:   .asciz "soustraction :"
+szMessMultiplication: .asciz "multiplication :"
+szMessDivision:       .asciz "division :"
+szMessReste:          .asciz "remainder :"
+
+/***********************/
+/* No Initialized data */
+/***********************/
+.bss
+qValeur:            .skip  8        // reserve 8 bytes in memory
+sZoneConv:          .skip 30
+.text
+.global main
+main:
+    mov fp,sp                   // fp <- stack address
+    ldr x0,[fp]                 // recup number of parameter in command line
+    cmp x0,3
+    blt error
+    ldr x0,[fp,16]              // adresse of 1er number
+    bl conversionAtoD
+    mov x3,x0
+    ldr x0,[fp,24]              // adresse of 2eme number
+    bl conversionAtoD
+    mov x4,x0
+                                // addition
+    add x0,x3,x4
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessAddition
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
+                                // soustraction
+    sub x0,x3,x4
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessSoustraction
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
+                                // multiplication
+    mul x0,x3,x4
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessMultiplication
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
+                                // division
+    mov x0,x3
+    mov x1,x4
+    udiv x0,x3,x4               // quotient
+    msub x3,x0,x4,x3            // remainder x3 = x3 - (x0*x4)
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessDivision
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
+
+    mov x0,x3                   // remainder
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessReste
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
+
+    mov x0,0                    // return code
+    b 100f
+error:
+    ldr x0,qAdrszMessError
+    bl affichageMess            // call function with 1 parameter (x0)
+    mov x0,1                    // return code
+100:                            // end of  program
+    mov x8,EXIT                 // request to exit program
+    svc 0                       // perform the system call
+qAdrsMessValeur:          .quad sMessValeur
+qAdrszMessResult:         .quad szMessResult
+qAdrszMessError:          .quad szMessError
+qAdrszMessAddition:       .quad szMessAddition
+qAdrszMessSoustraction:   .quad szMessSoustraction
+qAdrszMessMultiplication: .quad szMessMultiplication
+qAdrszMessDivision:       .quad szMessDivision
+qAdrszMessReste:          .quad szMessReste
+qAdrsZoneConv:            .quad sZoneConv
+/********************************************************/
+/*        File Include fonctions                        */
+/********************************************************/
+/* for this file see task include a file in language AArch64 assembly */
+.include "../includeARM64.inc"

Task/Arithmetic-Integer/ABAP/arithmetic-integer.abap

@@ -0,0 +1,25 @@
+report zz_arithmetic no standard page heading.
+
+" Read in the two numbers from the user.
+selection-screen begin of block input.
+  parameters: p_first type i,
+              p_second type i.
+selection-screen end of block input.
+
+" Set the text value that is displayed on input request.
+at selection-screen output.
+  %_p_first_%_app_%-text  = 'First Number: '.
+  %_p_second_%_app_%-text = 'Second Number: '.
+
+end-of-selection.
+  data: lv_result type i.
+  lv_result = p_first + p_second.
+  write: / 'Addition:', lv_result.
+  lv_result = p_first - p_second.
+  write: / 'Substraction:', lv_result.
+  lv_result = p_first * p_second.
+  write: / 'Multiplication:', lv_result.
+  lv_result = p_first div p_second.
+  write: / 'Integer quotient:', lv_result. " Truncated towards zero.
+  lv_result = p_first mod p_second.
+  write: / 'Remainder:',  lv_result.

Task/Arithmetic-Integer/ACL2/arithmetic-integer.acl2

@@ -0,0 +1,20 @@
+:set-state-ok t
+
+(defun get-two-nums (state)
+   (mv-let (_ a state)
+           (read-object *standard-oi* state)
+      (declare (ignore _))
+      (mv-let (_ b state)
+              (read-object *standard-oi* state)
+         (declare (ignore _))
+         (mv a b state))))
+
+(defun integer-arithmetic (state)
+   (mv-let (a b state)
+           (get-two-nums state)
+      (mv state
+          (progn$ (cw "Sum:        ~x0~%" (+ a b))
+                  (cw "Difference: ~x0~%" (- a b))
+                  (cw "Product:    ~x0~%" (* a b))
+                  (cw "Quotient:   ~x0~%" (floor a b))
+                  (cw "Remainder:  ~x0~%" (mod a b))))))

Task/Arithmetic-Integer/ALGOL-68/arithmetic-integer.alg

@@ -0,0 +1,10 @@
+main:(
+  LONG INT a=355, b=113;
+  printf(($"a PLUS b = a+b = "gl$, a + b));
+  printf(($"a MINUS b = a-b = "gl$, a - b));
+  printf(($"a TIMES b = a*b = a×b = "gl$, a * b));
+  printf(($"a DIV b = a/b = "gl$, a / b));
+  printf(($"a OVER b = a%b = a÷b = "gl$, a % b));
+  printf(($"a MOD b = a%*b = a%×b = a÷×b = a÷*b = "gl$, a %* b));
+  printf(($"a UP b = a**b = a↑b = "gl$, a ** b))
+)

Task/Arithmetic-Integer/ALGOL-W/arithmetic-integer.alg

@@ -0,0 +1,14 @@
+begin
+    integer a, b;
+    write( "Enter 2 integers> " );
+    read( a, b );
+    write( "a  +  b: ", a  +  b ); % addition         %
+    write( "a  -  b: ", a  -  b ); % subtraction      %
+    write( "a  *  b: ", a  *  b ); % multiplication   %
+    write( "a  /  b: ", a div b ); % integer division %
+    write( "a mod b: ", a rem b ); % modulo           %
+    % the ** operator returns a real result even with integer operands  %
+    % ( the right-hand operand must always be an integer, the left-hand %
+    % operand can be integer, real or complex )                         %
+    write( "a  ^  b: ", round( a ** b ) )
+end.

Task/Arithmetic-Integer/APL/arithmetic-integer.apl

@@ -0,0 +1,5 @@
+∇res ← integer_arithmetic; l; r
+  l ← ⎕
+  r ← ⎕
+  res ← 6 2 ⍴ 'sum' (l+r) 'diff' (l-r) 'prod' (l×r) 'quot' (⌊l÷r) 'rem' (r|l) 'pow' (l*r)
+∇

Task/Arithmetic-Integer/ARM-Assembly/arithmetic-integer.arm

@@ -0,0 +1,287 @@
+/* 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	

Task/Arithmetic-Integer/AWK/arithmetic-integer.awk

@@ -0,0 +1,8 @@
+/^[ \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 }

Task/Arithmetic-Integer/Action-/arithmetic-integer.action

@@ -0,0 +1,36 @@
+DEFINE NO_KEY="255"
+DEFINE KEY_Y="43"
+DEFINE KEY_N="35"
+
+PROC Main()
+  BYTE CH=$02FC ;Internal hardware value for last key pressed
+  BYTE k
+  INT a,b
+
+  DO
+    Print("Input integer value a=")
+    a=InputI()
+    Print("Input integer value b=")
+    b=InputI()
+
+    PrintF("a+b=%I%E",a+b)
+    PrintF("a-b=%I%E",a-b)
+    PrintF("a*b=%I%E",a*b)
+    PrintF("a/b=%I%E",a/b)
+    PrintF("a MOD b=%I%E",a MOD b)
+
+    PutE()
+    PrintE("Again? (Y/N)")
+
+    CH=NO_KEY ;Flush the keyboard
+    DO
+      k=CH
+    UNTIL k=KEY_Y OR k=KEY_N
+    OD
+    CH=NO_KEY ;Flush the keyboard
+
+    IF k=KEY_N THEN
+      EXIT
+    FI
+  OD
+RETURN

Task/Arithmetic-Integer/Ada/arithmetic-integer.ada

@@ -0,0 +1,20 @@
+with Ada.Text_Io;
+with Ada.Integer_Text_IO;
+
+procedure Integer_Arithmetic is
+   use Ada.Text_IO;
+   use Ada.Integer_Text_Io;
+
+   A, B : Integer;
+begin
+   Get(A);
+   Get(B);
+   Put_Line("a+b = " & Integer'Image(A + B));
+   Put_Line("a-b = " & Integer'Image(A - B));
+   Put_Line("a*b = " & Integer'Image(A * B));
+   Put_Line("a/b = " & Integer'Image(A / B));
+   Put_Line("a mod b = " & Integer'Image(A mod B)); -- Sign matches B
+   Put_Line("remainder of a/b = " & Integer'Image(A rem B)); -- Sign matches A
+   Put_Line("a**b = " & Integer'Image(A ** B));
+
+end Integer_Arithmetic;

Task/Arithmetic-Integer/Aikido/arithmetic-integer.aikido

@@ -0,0 +1,10 @@
+var a = 0
+var b = 0
+stdin -> a    // read int from stdin
+stdin -> b    // read int from stdin
+
+println ("a+b=" + (a + b))
+println ("a-b=" + (a - b))
+println ("a*b=" + (a * b))
+println ("a/b=" + (a / b))
+println ("a%b=" + (a % b))

Task/Arithmetic-Integer/AmigaE/arithmetic-integer.amiga

@@ -0,0 +1,14 @@
+PROC main()
+  DEF a, b, t
+  WriteF('A = ')
+  ReadStr(stdin, t)
+  a := Val(t)
+  WriteF('B = ')
+  ReadStr(stdin, t)
+  b := Val(t)
+  WriteF('A+B=\d\nA-B=\d\n', a+b, a-b)
+  WriteF('A*B=\d\nA/B=\d\n', a*b, a/b)
+  /* * and / are 16 bit ops; Mul and Div are 32bit ops */
+  WriteF('A*B=\d\nA/B=\d\n', Mul(a,b), Div(a,b))
+  WriteF('A mod B =\d\n', Mod(a,b))
+ENDPROC

Task/Arithmetic-Integer/AppleScript/arithmetic-integer-1.applescript

@@ -0,0 +1,11 @@
+set i1 to (text returned of (display dialog "Enter an integer value" default answer "")) as integer
+set i2 to (text returned of (display dialog "Enter another integer value" default answer "")) as integer
+
+set sum to i1 + i2
+set diff to i1 - i2
+set prod to i1 * i2
+set quot to i1 div i2 -- Rounds towards zero.
+set remainder to i1 mod i2 -- The result's sign matches the dividend's.
+set exp to i1 ^ i2 -- The result's always a real.
+
+return {|integers|:{i1, i2}, difference:diff, product:prod, quotient:quot, remainder:remainder, exponientiation:exp}

Task/Arithmetic-Integer/AppleScript/arithmetic-integer-2.applescript

@@ -0,0 +1 @@
+{|integers|:{-57, 2}, difference:-59, product:-114, quotient:-28, remainder:-1, exponientiation:3249.0}

Task/Arithmetic-Integer/Arturo/arithmetic-integer.arturo

@@ -0,0 +1,9 @@
+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]

Task/Arithmetic-Integer/Asymptote/arithmetic-integer.asymptote

@@ -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);

Task/Arithmetic-Integer/AutoHotkey/arithmetic-integer.ahk

@@ -0,0 +1,19 @@
+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

Task/Arithmetic-Integer/Avail/arithmetic-integer.avail

@@ -0,0 +1,12 @@
+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”;
+];

Task/Arithmetic-Integer/BASIC256/arithmetic-integer.basic

@@ -0,0 +1,9 @@
+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)

Task/Arithmetic-Integer/BBC-BASIC/arithmetic-integer.basic

@@ -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%

Task/Arithmetic-Integer/BaCon/arithmetic-integer.bacon

@@ -0,0 +1,12 @@
+' 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%))

Task/Arithmetic-Integer/Batch-File/arithmetic-integer.bat

@@ -0,0 +1,4 @@
+set /p equation=
+set /a result=%equation%
+echo %result%
+pause

Task/Arithmetic-Integer/Bc/arithmetic-integer.bc

@@ -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
+}

Task/Arithmetic-Integer/Befunge/arithmetic-integer.bf

@@ -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="<

Task/Arithmetic-Integer/Bracmat/arithmetic-integer.bracmat

@@ -0,0 +1,17 @@
+  ( enter
+  =     put$"Enter two integer numbers, separated by space:"
+      & get':(~/#?k_~/#?m|quit:?k)
+    |     out
+        $ "You must enter two integer numbers! Enter \"quit\" if you don't know how to do that."
+      & !enter
+  )
+& !enter
+& !k:~quit
+& out$("You entered" !k and !m ". Now look:")
+& out$("Sum:" !k+!m)
+& out$("Difference:" !k+-1*!m)
+& out$("Product:" !k*!m)
+& out$("Integer division:" div$(!k.!m))
+& out$("Remainder:" mod$(!k.!m))
+& out$("Exponentiation:" !k^!m)
+& done;

Task/Arithmetic-Integer/Brat/arithmetic-integer.brat

@@ -0,0 +1,7 @@
+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}"

Task/Arithmetic-Integer/C++/arithmetic-integer.cpp

@@ -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;
+}

Task/Arithmetic-Integer/C-sharp/arithmetic-integer.cs

@@ -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));
+    }
+}

Task/Arithmetic-Integer/C/arithmetic-integer.c

@@ -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;
+}

Task/Arithmetic-Integer/COBOL/arithmetic-integer.cobol

@@ -0,0 +1,44 @@
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. Int-Arithmetic.
+
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+
+       01 A      PIC S9(10).
+       01 B      PIC S9(10).
+       01 Result PIC S9(10).
+
+       PROCEDURE DIVISION.
+           DISPLAY "First number: " WITH NO ADVANCING
+           ACCEPT A
+           DISPLAY "Second number: " WITH NO ADVANCING
+           ACCEPT B
+
+*          *> Note: The various ADD/SUBTRACT/etc. statements can be
+*          *> replaced with COMPUTE statements, which allow those
+*          *> operations to be defined similarly to other languages,
+*          *> e.g. COMPUTE Result = A + B
+
+           ADD A TO B GIVING Result
+           DISPLAY "A + B = " Result
+
+           SUBTRACT B FROM A GIVING Result
+           DISPLAY "A - B = " Result
+
+           MULTIPLY A BY B GIVING Result
+           DISPLAY "A * B = " Result
+
+*          *> Division here truncates towards zero. DIVIDE can take a
+*          *> ROUNDED clause, which will round the result to the nearest
+*          *> integer.
+           DIVIDE A BY B GIVING Result
+           DISPLAY "A / B = " Result
+
+           COMPUTE Result = A ^ B
+           DISPLAY "A ^ B = " Result
+
+*          *> Matches sign of first argument.
+           DISPLAY "A % B = " FUNCTION REM(A, B)
+
+           GOBACK
+           .

Task/Arithmetic-Integer/Chef/arithmetic-integer.chef

@@ -0,0 +1,36 @@
+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.

Task/Arithmetic-Integer/Clipper/arithmetic-integer.clipper

@@ -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

Task/Arithmetic-Integer/Clojure/arithmetic-integer.clj

@@ -0,0 +1,6 @@
+(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))))))

Task/Arithmetic-Integer/Commodore-BASIC/arithmetic-integer-1.basic

@@ -0,0 +1,8 @@
+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%

Task/Arithmetic-Integer/Commodore-BASIC/arithmetic-integer-2.basic

@@ -0,0 +1,21 @@
+    LET A = 5
+    LET B = 3
+    PRINT "A = ", A, ",  B = ", B
+    PRINT ""
+    PRINT A," + ",B," = ", A+B
+    PRINT A," - ",B," = ", A-B
+    PRINT A," * ",B," = ", A*B
+    PRINT A," / ",B," = ", A/B
+    PRINT A," % ",B," = ", A-(A/B)*B
+    REM Exponent calculation
+    LET X = 1
+    LET E = 0
+10  IF X >= B THEN GOTO 30
+    LET T = E
+    IF E < A THEN LET E = A*A
+    IF T < A THEN GOTO 20
+    IF E >= A THEN LET E = E*A
+20  LET X = X+1
+    GOTO 10
+30  PRINT A," ^ ",B," = ", E
+    END

Task/Arithmetic-Integer/Common-Lisp/arithmetic-integer.lisp

@@ -0,0 +1,6 @@
+(defun arithmetic (&optional (a (read *query-io*)) (b (read *query-io*)))
+  (mapc
+    (lambda (op)
+      (format t "~a => ~a~%" (list op a b) (funcall (symbol-function op) a b)))
+    '(+ - * mod rem floor ceiling truncate round expt))
+  (values))

Task/Arithmetic-Integer/Component-Pascal/arithmetic-integer-1.pas

@@ -0,0 +1,28 @@
+MODULE Arithmetic;
+IMPORT CPmain,Console,RTS;
+
+VAR
+   x,y	  : INTEGER;
+   arg	  : ARRAY 128 OF CHAR;
+   status : BOOLEAN;
+
+
+PROCEDURE Error(IN str : ARRAY OF CHAR);
+BEGIN
+   Console.WriteString(str);Console.WriteLn;
+   HALT(1)
+END Error;
+
+
+BEGIN
+   IF CPmain.ArgNumber() < 2 THEN Error("Give me two integers!") END;
+   CPmain.GetArg(0,arg); RTS.StrToInt(arg,x,status);
+   IF ~status THEN Error("Can't convert 	'"+arg+"' to Integer") END;
+   CPmain.GetArg(1,arg); RTS.StrToInt(arg,y,status);
+   IF ~status THEN Error("Can't convert '"+arg+"' to Integer") END;
+   Console.WriteString("x + y >");Console.WriteInt(x + y,6);Console.WriteLn;
+   Console.WriteString("x - y >");Console.WriteInt(x - y,6);Console.WriteLn;
+   Console.WriteString("x * y >");Console.WriteInt(x * y,6);Console.WriteLn;
+   Console.WriteString("x / y >");Console.WriteInt(x DIV y,6);Console.WriteLn;
+   Console.WriteString("x MOD y >");Console.WriteInt(x MOD y,6);Console.WriteLn;
+END Arithmetic.

Task/Arithmetic-Integer/Component-Pascal/arithmetic-integer-2.pas

@@ -0,0 +1,33 @@
+MODULE Arithmetic;
+IMPORT StdLog,DevCommanders,TextMappers;
+
+PROCEDURE DoArithmetic(x,y: INTEGER);
+BEGIN
+        StdLog.String("x + y >");StdLog.Int(x + y);StdLog.Ln;
+        StdLog.String("x - y >");StdLog.Int(x - y);StdLog.Ln;
+        StdLog.String("x * y >");StdLog.Int(x * y);StdLog.Ln;
+        StdLog.String("x / y >");StdLog.Int(x DIV y);StdLog.Ln;
+        StdLog.String("x MOD y >");StdLog.Int(x MOD y);StdLog.Ln;
+END DoArithmetic;
+
+PROCEDURE Go*;
+VAR
+                params: DevCommanders.Par;
+                s: TextMappers.Scanner;
+                p : ARRAY 2 OF INTEGER;
+                current: INTEGER;
+BEGIN
+        current := 0;
+        params := DevCommanders.par;
+        s.ConnectTo(params.text);
+        s.SetPos(params.beg);
+        s.Scan;
+        WHILE(~s.rider.eot) DO
+                IF (s.type = TextMappers.int) THEN
+                        p[current] := s.int; INC(current);
+                END;
+                s.Scan;
+        END;
+        IF current = 2 THEN DoArithmetic(p[0],p[1]) END;
+END Go;
+END Arithmetic.

Task/Arithmetic-Integer/Crystal/arithmetic-integer.crystal

@@ -0,0 +1,10 @@
+a = gets.not_nil!.to_i64
+b = gets.not_nil!.to_i64
+
+puts "Sum: #{a + b}"
+puts "Difference: #{a - b}"
+puts "Product: #{a * b}"
+puts "Quotient (float division): #{a / b}"  # / always returns a float.
+puts "Quotient (floor division): #{a // b}"
+puts "Remainder: #{a % b}" # Sign of remainder matches that of the second operand (b).
+puts "Power: #{a ** b}"    # Integers can only be raised to a positive exponent.

Task/Arithmetic-Integer/D/arithmetic-integer-1.d

@@ -0,0 +1,17 @@
+import std.stdio, std.string, std.conv;
+
+void main() {
+    int a = 10, b = 20;
+    try {
+        a = readln().strip().to!int();
+        b = readln().strip().to!int();
+    } catch (StdioException e) {}
+    writeln("a = ", a, ", b = ", b);
+
+    writeln("a + b = ", a + b);
+    writeln("a - b = ", a - b);
+    writeln("a * b = ", a * b);
+    writeln("a / b = ", a / b);
+    writeln("a % b = ", a % b);
+    writeln("a ^^ b = ", a ^^ b);
+}

Task/Arithmetic-Integer/D/arithmetic-integer-2.d

@@ -0,0 +1,13 @@
+import std.stdio, std.string, std.conv, std.meta;
+
+void main() {
+    int a = -16, b = 5;
+    try {
+        a = readln().strip().to!int();
+        b = readln().strip().to!int();
+    } catch (StdioException e) {}
+    writeln("a = ", a, ", b = ", b);
+
+    foreach (op; AliasSeq!("+", "-", "*", "/", "%", "^^"))
+        mixin(`writeln("a ` ~ op ~ ` b = ", a` ~ op ~ `b);`);
+}

Task/Arithmetic-Integer/DCL/arithmetic-integer.dcl

@@ -0,0 +1,8 @@
+$ inquire a "Enter first number"
+$ a = f$integer( a )
+$ inquire b "Enter second number"
+$ b = f$integer( b )
+$ write sys$output "a + b = ", a + b
+$ write sys$output "a - b = ", a - b
+$ write sys$output "a * b = ", a * b
+$ write sys$output "a / b = ", a / b  ! truncates down

Task/Arithmetic-Integer/DWScript/arithmetic-integer.dw

@@ -0,0 +1,9 @@
+var a := StrToInt(ParamStr(0));
+var b := StrToInt(ParamStr(1));
+
+PrintLn(Format('%d + %d = %d', [a, b, a + b]));
+PrintLn(Format('%d - %d = %d', [a, b, a - b]));
+PrintLn(Format('%d * %d = %d', [a, b, a * b]));
+PrintLn(Format('%d / %d = %d', [a, b, a div b]));
+PrintLn(Format('%d mod %d = %d', [a, b, a mod b]));
+PrintLn(Format('%d ^ %d = %d', [a, b, Trunc(Power(a, b))]));

Task/Arithmetic-Integer/Dc/arithmetic-integer.dc

@@ -0,0 +1,10 @@
+[Enter 2 integers on 1 line.
+  Use whitespace to separate. Example: 2 3
+  Use underscore for negative integers. Example: _10
+]P ? sb sa
+[add: ]P la lb + p sz
+[sub: ]P la lb - p sz
+[mul: ]P la lb * p sz
+[div: ]P la lb / p sz  [truncates toward zero]sz
+[mod: ]P la lb % p sz  [sign matches first operand]sz
+[pow: ]P la lb ^ p sz

Task/Arithmetic-Integer/Delphi/arithmetic-integer.delphi

@@ -0,0 +1,19 @@
+program IntegerArithmetic;
+
+{$APPTYPE CONSOLE}
+
+uses SysUtils, Math;
+
+var
+  a, b: Integer;
+begin
+  a := StrToInt(ParamStr(1));
+  b := StrToInt(ParamStr(2));
+
+  WriteLn(Format('%d + %d = %d', [a, b, a + b]));
+  WriteLn(Format('%d - %d = %d', [a, b, a - b]));
+  WriteLn(Format('%d * %d = %d', [a, b, a * b]));
+  WriteLn(Format('%d / %d = %d', [a, b, a div b])); // rounds towards 0
+  WriteLn(Format('%d %% %d = %d', [a, b, a mod b])); // matches sign of the first operand
+  WriteLn(Format('%d ^ %d = %d', [a, b, Trunc(Power(a, b))]));
+end.

Task/Arithmetic-Integer/Dyalect/arithmetic-integer.dyalect

@@ -0,0 +1,8 @@
+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)")

Task/Arithmetic-Integer/E/arithmetic-integer.e

@@ -0,0 +1,8 @@
+def arithmetic(a :int, b :int) {
+  return `$\
+   Sum:        ${a + b}
+   Difference: ${a - b}
+   Product:    ${a * b}
+   Quotient:   ${a // b}
+   Remainder:  ${a % b}$\n`
+}

Task/Arithmetic-Integer/ECL/arithmetic-integer.ecl

@@ -0,0 +1,31 @@
+ArithmeticDemo(INTEGER A,INTEGER B) := FUNCTION
+  ADDit       := A + B;
+  SUBTRACTit  := A - B;
+  MULTIPLYit  := A * B;
+  INTDIVIDEit := A DIV B; //INTEGER DIVISION
+  DIVIDEit    := A / B;   //standard division
+  Remainder   := A % B;
+  EXPit       := POWER(A,B);
+  DS          := DATASET([{A,B,'A PLUS B is:',ADDit},
+                          {A,B,'A MINUS B is:',SUBTRACTit},
+			  {A,B,'A TIMES B is:',MULTIPLYit},
+			  {A,B,'A INT DIVIDE BY B is:',INTDIVIDEit},
+			  {A,B,'REMAINDER is:',Remainder},
+			  {A,B,'A DIVIDE BY B is:',DIVIDEit},
+			  {A,B,'A RAISED TO B:',EXPit}],
+			  {INTEGER AVal,INTEGER BVal,STRING18 valuetype,STRING val});
+										
+  RETURN DS;
+  END;
+	
+ArithmeticDemo(1,1);
+ArithmeticDemo(2,2);
+ArithmeticDemo(50,5);
+ArithmeticDemo(10,3);
+ArithmeticDemo(-1,2);
+	
+/* 	NOTE:Division by zero defaults to generating a zero result (0),
+   	rather than reporting a “divide by zero” error.
+   	This avoids invalid or unexpected data aborting a long job.
+   	This default behavior can be changed
+*/

Task/Arithmetic-Integer/EMal/arithmetic-integer.emal

@@ -0,0 +1,30 @@
+^|EMal has no divmod operator or built-in function,
+ |its interface can be easily emulated as shown below.
+ |The performace is worse than using / and % operators.
+ |^
+fun divmod = Pair by int dividend, int divisor
+  Pair result = int%int().named("quotient", "remainder")
+  result.quotient = dividend / divisor
+  result.remainder = dividend % divisor
+  return result
+end
+fun main = int by List args
+  int a, b
+  if args.length == 2
+    a = int!args[0]
+	b = int!args[1]
+  else
+    a = ask(int, "first number: ")
+    b = ask(int, "second number: ")
+  end
+  writeLine("sum:              " + (a + b))
+  writeLine("difference:       " + (a - b))
+  writeLine("product:          " + (a * b))
+  writeLine("integer quotient: " + (a / b)) # truncates towards 0
+  writeLine("remainder:        " + (a % b)) # matches sign of first operand
+  writeLine("exponentiation:   " + (a ** b))
+  writeLine("logarithm:        " + (a // b))
+  writeLine("divmod:           " + divmod(a, b))
+  return 0
+end
+exit main(Runtime.args)

Task/Arithmetic-Integer/ERRE/arithmetic-integer.erre

@@ -0,0 +1,19 @@
+PROGRAM INTEGER_ARITHMETIC
+
+!
+! for rosettacode.org
+!
+
+!$INTEGER
+
+BEGIN
+  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;"div";B;"=";(A DIV B))
+  PRINT("Remainder or modulo ";A;"mod";B;"=";(A MOD B))
+  PRINT("Power ";A;"^";B;"=";(A^B))
+END PROGRAM

Task/Arithmetic-Integer/EasyLang/arithmetic-integer.easy

@@ -0,0 +1,8 @@
+a = number input
+b = number input
+print a + b
+print a - b
+print a * b
+print a div b
+print a mod b
+print pow a b

Task/Arithmetic-Integer/Efene/arithmetic-integer.efene

@@ -0,0 +1,15 @@
+@public
+run = fn () {
+
+    First = io.get_line("First number: ")
+    Second = io.get_line("Second number: ")
+
+    A = list_to_integer(lists.delete($\n, First))
+    B = list_to_integer(lists.delete($\n, Second))
+
+    io.format("Sum: ~p~n", [A + B])
+    io.format("Difference: ~p~n", [A - B])
+    io.format("Product: ~p~n", [A * B])
+    io.format("Quotient: ~p~n", [A / B])
+    io.format("Remainder: ~p~n", [A % B])
+}

Task/Arithmetic-Integer/Eiffel/arithmetic-integer.e

@@ -0,0 +1,29 @@
+class MAIN
+    creation make
+    feature make is
+        local
+            a, b: REAL;
+        do
+            print("a = ");
+            io.read_real;
+            a := io.last_real;
+
+            print("b = ");
+            io.read_real;
+            b := io.last_real;
+
+            print("a + b = ");
+            io.put_real(a + b);
+            print("%Na - b = ");
+            io.put_real(a - b);
+            print("%Na * b = ");
+            io.put_real(a * b);
+            print("%Na / b = ");
+            io.put_real(a / b);
+            print("%Na %% b = ");
+            io.put_real(((a / b) - (a / b).floor) * b);
+            print("%Na ^ b = ");
+            io.put_real(a.pow(b));
+            print("%N");
+        end
+end

Task/Arithmetic-Integer/Elena/arithmetic-integer.elena

@@ -0,0 +1,15 @@
+import system'math;
+import extensions;
+
+public program()
+{
+    var a := console.loadLineTo(new Integer());
+    var b := console.loadLineTo(new Integer());
+
+    console.printLine(a," + ",b," = ",a + b);
+    console.printLine(a," - ",b," = ",a - b);
+    console.printLine(a," * ",b," = ",a * b);
+    console.printLine(a," / ",b," = ",a / b);   // truncates towards 0
+    console.printLine(a," % ",b," = ",a.mod:b); // matches sign of first operand
+    console.printLine(a," ^ ",b," = ",a ^ b);
+}

Task/Arithmetic-Integer/Elixir/arithmetic-integer.elixir

@@ -0,0 +1,25 @@
+defmodule Arithmetic_Integer do
+  # Function to remove line breaks and convert string to int
+  defp get_int(msg) do
+    IO.gets(msg) |> String.strip |> String.to_integer
+  end
+
+  def task do
+    # Get user input
+    a = get_int("Enter your first integer: ")
+    b = get_int("Enter your second integer: ")
+
+    IO.puts "Elixir Integer Arithmetic:\n"
+    IO.puts "Sum:            #{a + b}"
+    IO.puts "Difference:     #{a - b}"
+    IO.puts "Product:        #{a * b}"
+    IO.puts "True Division:  #{a / b}"                  # Float
+    IO.puts "Division:       #{div(a,b)}"               # Truncated Towards 0
+    IO.puts "Floor Division: #{Integer.floor_div(a,b)}" # floored integer division
+    IO.puts "Remainder:      #{rem(a,b)}"               # Sign from first digit
+    IO.puts "Modulo:         #{Integer.mod(a,b)}"       # modulo remainder (uses floored division)
+    IO.puts "Exponent:       #{:math.pow(a,b)}"         # Float, using Erlang's :math
+  end
+end
+
+Arithmetic_Integer.task

Task/Arithmetic-Integer/Emojicode/arithmetic-integer.emojicode

@@ -0,0 +1,9 @@
+🏁🍇
+  🍺🔢🆕🔡▶️👂🏼❗ 10❗️ ➡️ x 💭 Get first number
+  🍺🔢🆕🔡▶️👂🏼❗ 10❗️ ➡️ y 💭 Get second number
+  😀 🔤Sum: 🧲x➕y🧲🔤 ❗
+  😀 🔤Difference: 🧲x➖y🧲🔤 ❗
+  😀 🔤Product: 🧲x✖️y🧲🔤 ❗
+  😀 🔤Quotient: 🧲x➗️y🧲🔤 ❗ 💭 Rounds towards 0
+  😀 🔤Remainder: 🧲x🚮️y🧲🔤 ❗ 💭 Matches sign of first operand
+🍉️

Task/Arithmetic-Integer/Erlang/arithmetic-integer.erl

@@ -0,0 +1,14 @@
+% Implemented by Arjun Sunel
+-module(arith).
+-export([start/0]).
+
+start() ->
+   case io:fread("","~d~d") of
+       {ok, [A,B]} ->
+           io:format("Sum = ~w~n",[A+B]),
+           io:format("Difference = ~w~n",[A-B]),
+           io:format("Product = ~w~n",[A*B]),
+           io:format("Quotient = ~w~n",[A div B]),      % truncates towards zero
+           io:format("Remainder= ~w~n",[A rem B]),    % same sign as the first operand
+           halt()
+   end.

Task/Arithmetic-Integer/Euphoria/arithmetic-integer.euphoria

@@ -0,0 +1,13 @@
+include get.e
+
+integer a,b
+
+a = floor(prompt_number("a = ",{}))
+b = floor(prompt_number("b = ",{}))
+
+printf(1,"a + b = %d\n", a+b)
+printf(1,"a - b = %d\n", a-b)
+printf(1,"a * b = %d\n", a*b)
+printf(1,"a / b = %g\n", a/b) -- does not truncate
+printf(1,"remainder(a,b) = %d\n", remainder(a,b)) -- same sign as first operand
+printf(1,"power(a,b) = %g\n", power(a,b))

Task/Arithmetic-Integer/Excel/arithmetic-integer-1.excel

@@ -0,0 +1 @@
+=$A1+$B1

Task/Arithmetic-Integer/Excel/arithmetic-integer-2.excel

@@ -0,0 +1 @@
+=$A1-$B1

Task/Arithmetic-Integer/Excel/arithmetic-integer-3.excel

@@ -0,0 +1 @@
+=$A1*$B1

Task/Arithmetic-Integer/Excel/arithmetic-integer-4.excel

@@ -0,0 +1 @@
+=QUOTIENT($A1,$B1)

Task/Arithmetic-Integer/Excel/arithmetic-integer-5.excel

@@ -0,0 +1 @@
+=MOD($A1,$B1)

Task/Arithmetic-Integer/Excel/arithmetic-integer-6.excel

@@ -0,0 +1 @@
+=$A1^$B1

Task/Arithmetic-Integer/F-Sharp/arithmetic-integer-1.fs

@@ -0,0 +1,4 @@
+do
+  let a, b = int Sys.argv.[1], int Sys.argv.[2]
+  for str, f in ["+", ( + ); "-", ( - ); "*", ( * ); "/", ( / ); "%", ( % )] do
+    printf "%d %s %d = %d\n" a str b (f a b)

Task/Arithmetic-Integer/F-Sharp/arithmetic-integer-2.fs

@@ -0,0 +1,5 @@
+4 + 3 = 7
+4 - 3 = 1
+4 * 3 = 12
+4 / 3 = 1
+4 % 3 = 1

Task/Arithmetic-Integer/FALSE/arithmetic-integer.false

@@ -0,0 +1,8 @@
+12 7
+\$@$@$@$@$@$@$@$@$@$@\  { 6 copies }
+"sum = "+."
+difference = "-."
+product = "*."
+quotient = "/."
+modulus = "/*-."
+"

Task/Arithmetic-Integer/Factor/arithmetic-integer.factor

@@ -0,0 +1,17 @@
+USING: combinators io kernel math math.functions math.order
+math.parser prettyprint ;
+
+"a=" "b=" [ write readln string>number ] bi@
+{
+    [ + "sum: " write . ]
+    [ - "difference: " write . ]
+    [ * "product: " write . ]
+    [ / "quotient: " write . ]
+    [ /i "integer quotient: " write . ]
+    [ rem "remainder: " write . ]
+    [ mod "modulo: " write . ]
+    [ max "maximum: " write . ]
+    [ min "minimum: " write . ]
+    [ gcd "gcd: " write . drop ]
+    [ lcm "lcm: " write . ]
+} 2cleave

Task/Arithmetic-Integer/Fermat/arithmetic-integer.fermat

@@ -0,0 +1,8 @@
+?a;
+?b;
+!!('Sum:              a+b=',a+b);
+!!('Difference:       a-b=',a-b);
+!!('Product:          a*b=',a*b);
+!!('Integer quotient: a\b=',a\b);
+!!('Remainder:        a|b=',a|b);
+!!('Exponentiation:   a^b=',a^b);

Task/Arithmetic-Integer/Forth/arithmetic-integer-1.fth

@@ -0,0 +1,7 @@
+: arithmetic ( a b -- )
+  cr ." a=" over . ." b=" dup .
+  cr ." a+b=" 2dup + .
+  cr ." a-b=" 2dup - .
+  cr ." a*b=" 2dup * .
+  cr ." a/b=" /mod .
+  cr ." a mod b = " . cr ;

Task/Arithmetic-Integer/Forth/arithmetic-integer-2.fth

@@ -0,0 +1,3 @@
+FM/MOD ( d n -- mod div )   \ floored
+SM/REM ( d n -- rem div )   \ symmetric
+M* ( n n -- d )

Task/Arithmetic-Integer/Forth/arithmetic-integer-3.fth

@@ -0,0 +1,2 @@
+UM/MOD ( ud u -- umod udiv )
+UM* ( u u -- ud )

Task/Arithmetic-Integer/Fortran/arithmetic-integer.f

@@ -0,0 +1,14 @@
+ INTEGER A, B
+ PRINT *, 'Type in two integer numbers separated by white space',
++         ' and press ENTER'
+ READ *, A, B
+ PRINT *, '   A + B = ', (A + B)
+ PRINT *, '   A - B = ', (A - B)
+ PRINT *, '   A * B = ', (A * B)
+ PRINT *, '   A / B = ', (A / B)
+ PRINT *, 'MOD(A,B) = ', MOD(A,B)
+ PRINT *
+ PRINT *, 'Even though you did not ask, ',
++         'exponentiation is an intrinsic op in Fortran, so...'
+ PRINT *, '  A ** B = ', (A ** B)
+ END

Task/Arithmetic-Integer/FreeBASIC/arithmetic-integer.basic

@@ -0,0 +1,16 @@
+' FB 1.05.0 Win64
+
+Dim As Integer i, j
+Input "Enter two integers separated by a comma"; i, j
+Print i;" + "; j; " = "; i + j
+Print i;" - "; j; " = "; i - j
+Print i;" * "; j; " = "; i * j
+Print i;" / "; j; " = "; i \ j
+Print i;" % "; j; " = "; i Mod j
+Print i;" ^ "; j; " = "; i ^ j
+Sleep
+
+' Integer division (for which FB uses the '\' operator) rounds towards zero
+
+' Remainder (for which FB uses the Mod operator) will, if non-zero, match the sign
+' of the first operand

Task/Arithmetic-Integer/Friendly-interactive-shell/arithmetic-integer.fish

@@ -0,0 +1,8 @@
+read a
+read b
+echo 'a + b =' (math "$a + $b") # Sum
+echo 'a - b =' (math "$a - $b") # Difference
+echo 'a * b =' (math "$a * $b") # Product
+echo 'a / b =' (math "$a / $b") # Integer quotient
+echo 'a % b =' (math "$a % $b") # Remainder
+echo 'a ^ b =' (math "$a ^ $b") # Exponentation

Task/Arithmetic-Integer/Frink/arithmetic-integer-1.frink

@@ -0,0 +1,7 @@
+[a,b] = input["Enter numbers",["a","b"]]
+ops=["+", "-", "*", "/", "div" ,"mod" ,"^"]
+for op = ops
+{
+   str = "$a $op $b"
+   println["$str = " + eval[str]]
+}

Task/Arithmetic-Integer/Frink/arithmetic-integer-2.frink

@@ -0,0 +1,7 @@
+10 + 20 = 30
+10 - 20 = -10
+10 * 20 = 200
+10 / 20 = 1/2 (exactly 0.5)
+10 div 20 = 0
+10 mod 20 = 10
+10 ^ 20 = 100000000000000000000

Task/Arithmetic-Integer/FutureBasic/arithmetic-integer-1.basic

@@ -0,0 +1,14 @@
+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

Task/Arithmetic-Integer/FutureBasic/arithmetic-integer-2.basic

@@ -0,0 +1,111 @@
+_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

Task/Arithmetic-Integer/GAP/arithmetic-integer.gap

@@ -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;

Task/Arithmetic-Integer/GDScript/arithmetic-integer.gd

@@ -0,0 +1,29 @@
+@tool
+extends Node
+
+@export var a: int:
+	set(value):
+		a = value
+		refresh()
+
+@export var b: int:
+	set(value):
+		b = value
+		refresh()
+
+# Output properties
+@export var sum: int
+@export var difference: int
+@export var product: int
+@export var integer_quotient: int
+@export var remainder: int
+@export var exponentiation: int
+@export var divmod: int
+
+func refresh():
+	sum = a + b
+	difference = a - b
+	product = a * b
+	integer_quotient = a / b # Rounds towards 0
+	remainder = a % b # Matches the sign of a
+	exponentiation = pow(a, b)

Task/Arithmetic-Integer/GEORGE/arithmetic-integer.george

@@ -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;

Task/Arithmetic-Integer/Gambas/arithmetic-integer.gambas

@@ -0,0 +1,18 @@
+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

Task/Arithmetic-Integer/Genie/arithmetic-integer.genie

@@ -0,0 +1,21 @@
+[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

Task/Arithmetic-Integer/Go/arithmetic-integer-1.go

@@ -0,0 +1,15 @@
+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
+}

Task/Arithmetic-Integer/Go/arithmetic-integer-2.go

@@ -0,0 +1,29 @@
+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
+}

Task/Arithmetic-Integer/Golfscript/arithmetic-integer.golf

@@ -0,0 +1 @@
+n/~~:b;~:a;a b+n a b-n a b*n a b/n a b%n a b?

Task/Arithmetic-Integer/Groovy/arithmetic-integer-1.groovy

@@ -0,0 +1,14 @@
+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}
+"""
+}

Task/Arithmetic-Integer/Groovy/arithmetic-integer-2.groovy

@@ -0,0 +1 @@
+arithmetic(5,3)

Task/Arithmetic-Integer/Harbour/arithmetic-integer.harbour

@@ -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

Task/Arithmetic-Integer/Haskell/arithmetic-integer.hs

@@ -0,0 +1,15 @@
+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)

Task/Arithmetic-Integer/Haxe/arithmetic-integer.haxe

@@ -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));
+    }
+}