zettacode 0.1.6 → 0.1.7

data/files.zettacode2/arithmetic.integer/0815}.txt

@@ -1,14 +0,0 @@
-
-|~>|~#: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:$==$~$=${{~%

data/files.zettacode2/arithmetic.integer/11l}.txt

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

data/files.zettacode2/arithmetic.integer/360_assembly.txt

@@ -1,55 +0,0 @@
-From the principles of operation: Operands are signed and 32 bits long. 
-Negative quantities are held in two's-complement form. 
-<br>'''Multiplication:'''<br>
-The product of the multiplier (the second operand) and the multiplicand 
-(the first operand) replaces the multiplicand. Both multiplier and 
-multiplicand are 32-bit signed integers. The product is always a 64-bit 
-signed integer and occupies an even/odd register pair.
-<br>'''Division:'''<br>
-The dividend (first operand) is divided by the divisor (second operand) 
-and replaced by the quotient and remainder. The dividend is a 64-bit 
-signed integer and occupies the even/odd pair of registers. 
-A 32-bit signed remainder and a 32-bit signed quotient replace the dividend 
-in the even-numbered and odd-numbered registers, respectively.
-The sign of the quotient is determined by the rules of algebra. 
-The remainder has the same sign as the dividend.
-*        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
-Inputs are in the code: a=53, b=11

data/files.zettacode2/arithmetic.integer/6502_assembly}.txt

@@ -1,50 +0,0 @@
-Code is called as a subroutine (i.e. JSR Arithmetic).  Specific OS/hardware routines for user input and printing are left unimplemented.
-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
-The 6502 has no opcodes for multiplication, division, or modulus; the routines for multiplication, division, and modulus given above can be heavily optimized at the expense of some clarity.

data/files.zettacode2/arithmetic.integer/68000_assembly.txt

@@ -1,24 +0,0 @@
-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
-
-Exponentiation doesn't exist but can be implemented in a similar fashion to multiplication on the 6502:
-
-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

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

@@ -1,137 +0,0 @@
-{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
-<syntaxhighlight lang="aarch64 assembly">
-/* 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"
-
-{{Output : }}
-<PRE>
-pi@debian-buster-64:~/asm64/rosetta/asm3 $ arith64 101 25
-Addition resultat : +126
-soustraction :resultat : +76
-multiplication :resultat : +2525
-division :resultat : +4
-remainder :resultat : +1
-</PRE>

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

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

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

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

data/files.zettacode2/arithmetic.integer/action!.txt

@@ -1,36 +0,0 @@
-<syntaxhighlight lang="action!">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

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

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

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

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

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

@@ -1,14 +0,0 @@
-{{trans|C}}
-{{works with|ALGOL 68|Revision 1 - no extensions to language used}}
-{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
-{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}
-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))
-)

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

@@ -1,16 +0,0 @@
-The Algol W integer division operator (called div) truncates towards zero.<br>
-The result of the modulo operator (called rem) has the sign of the first operand when the operands have different signs.
-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.

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

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

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

@@ -1,7 +0,0 @@
-∇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)
-∇
-
-Quotient will round down in this version.

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

@@ -1,16 +0,0 @@
-
-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}
-
-{{output}}
-
-{|integers|:{-57, 2}, difference:-59, product:-114, quotient:-28, remainder:-1, exponientiation:3249.0}