zettacode 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f579bfba963a1101694ba42d392732b0367d61d32d0e7464c546dc544557668d
-  data.tar.gz: 6501f595e29aedf44aadd2cbfd6028e05bc674b23a6550d8d538cd4c800c5525
+  metadata.gz: ae2df517beff7796650021bf0fba7de819ec55080ad053a469e13095d6c011de
+  data.tar.gz: 836c53f4420566b2b4b8368028d8e55f6e3e28a4e147a5f6b3822fc613539e11
 SHA512:
-  metadata.gz: 2160249bac68d769b0a42adc3ea2d5bc858244e030049ddf8491492c134cc8c5ca5388435f104d1ae8935ee08d239217cf4e0cfbad20e689f7d8ff275b687ce8
-  data.tar.gz: aa85239d535347aa2ee08352e89387bbb01d297c0dea2f3783fe9a23757e13213ccfc64ae779567892c841365d6b6a346cea818331944eb67bd99cbb82994049
+  metadata.gz: 6265a82dbe96221b8bb3833fd493113285488d2a3d92210d9aba37181f4c1e222b707497dec85b765b0417ffcf1f541bac82771eea0fadad21bc2298cda670b3
+  data.tar.gz: 0ca96af084802f24e8efd9e852e66f08b336b5e87f570fc0a75f74e799216528ee372f3508bec796b7fa3265f4f4f05d51ce681c057d42238f1466b49aa72922

data/README.md

@@ -26,7 +26,7 @@ Features:
 ## 1.1 Installation
 
 * Install Ruby on your host.
-* `ruby -v`, check current Ruby version.
+* `ruby -v`, check current Ruby version (Require version >= 3.1.0) 
 * `gem install zettacode`, to install "zettacode" gem.
 * `zettacode -v`, show current version.
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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