June 2018 Update

Task/Array-concatenation/Aime/array-concatenation.aime

@@ -3,10 +3,10 @@ ac(list a, list b)
 {
     list o;
 
-    l_ucall(a, l_append, 1, o);
-    l_ucall(b, l_append, 1, o);
+    o.copy(a);
+    b.ucall(l_append, 1, o);
 
-    return o;
+    o;
 }
 
 integer
@@ -14,12 +14,12 @@ main(void)
 {
     list a, b, c;
 
-    a = l_effect(1, 2, 3, 4);
-    b = l_effect(5, 6, 7, 8);
+    a = list(1, 2, 3, 4);
+    b = list(5, 6, 7, 8);
 
     c = ac(a, b);
 
-    l_ucall(c, o_, 1, " ");
+    c.ucall(o_, 1, " ");
 
     return 0;
 }

Task/Array-concatenation/Common-Lisp/array-concatenation-2.lisp

@@ -0,0 +1,13 @@
+(setf arr1 (make-array '(3) :initial-contents '(1 2 3)))
+(setf arr2 (make-array '(3) :initial-contents '(4 5 6)))
+(setf arr3 (make-array '(3) :initial-contents '(7 8 9)))
+(setf arr4 (make-array '(6)))
+(setf arr5 (make-array '(9)))
+(setf arr4 (concatenate `(vector ,(array-element-type arr1)) arr1 arr2))
+(format t "~a" "concatenate arr1 and arr2: ")
+(write arr4)
+(terpri)
+(setf arr5 (concatenate `(vector ,(array-element-type arr1)) arr4 arr3))
+(format t "~a" "concatenate arr4 and arr3: ")
+(write arr5)
+(terpri)

Task/Array-concatenation/Elena/array-concatenation.elena

@@ -1,6 +1,6 @@
 import extensions.
 
-program =
+public program =
 [
     var a := (1,2,3).
     var b := (4,5).

Task/Array-concatenation/Fortran/array-concatenation.f

@@ -0,0 +1,21 @@
+program Concat_Arrays
+implicit none
+
+  ! Note: in Fortran 90 you must use the old array delimiters (/ , /)
+  integer, dimension(3) :: a = [1, 2, 3] ! (/1, 2, 3/)
+  integer, dimension(3) :: b = [4, 5, 6] ! (/4, 5, 6/)
+  integer, dimension(:), allocatable :: c, d
+
+  allocate(c(size(a)+size(b)))
+  c(1 : size(a)) = a
+  c(size(a)+1 : size(a)+size(b)) = b
+  write(*,*) c
+
+  ! alternative
+  d = [a, b] ! (/a, b/)
+  write(*,*) d
+
+  deallocate(c)
+  deallocate(d)
+
+end program Concat_Arrays

Task/Array-concatenation/Klong/array-concatenation.klong

@@ -0,0 +1,8 @@
+    [1 2 3],[4 5 6]               :" join "
+[1 2 3 4 5 6]
+
+    [1 2],:\[[3 4] [5 6] [7 8]]   :" join each-left "
+[[1 2 3 4] [1 2 5 6] [1 2 7 8]]
+
+    [1 2],:/[[3 4] [5 6] [7 8]]   :" join each-right "
+[[3 4 1 2] [5 6 1 2] [7 8 1 2]]

Task/Array-concatenation/Limbo/array-concatenation.limbo

@@ -0,0 +1,23 @@
+implement Command;
+
+include "sys.m";
+sys: Sys;
+
+include "draw.m";
+
+include "sh.m";
+
+init(nil: ref Draw->Context, nil: list of string)
+{
+	sys = load Sys Sys->PATH;
+
+	a := array[] of {1, 2};
+	b := array[] of {3, 4, 5};
+
+	c := array[len a + len b] of int;
+	c[:] = a;
+	c[len a:] = b;
+
+	for (i := 0; i < len c; i++)
+		sys->print("%d\n", c[i]);
+}

Task/Array-concatenation/Oforth/array-concatenation.oforth

@@ -1 +1,3 @@
+import: mapping
+
 [1, 2, 3 ] [ 4, 5, 6, 7 ] +

Task/Array-concatenation/Red/array-concatenation.red

@@ -0,0 +1,12 @@
+>> arr1: ["a" "b" "c"]
+>> arr2: ["d" "e" "f"]
+>> append arr1 arr2
+== ["a" "b" "c" "d" "e" "f"]
+>> arr3: [1 2 3]
+>> insert arr1 arr3
+>> arr1
+== [1 2 3 "a" "b" "c" "d" "e" "f"]
+>> arr4: [22 33 44]
+== [22 33 44]
+>> append/only arr1 arr4
+== [1 2 3 "a" "b" "c" "d" "e" "f" [22 33 44]]

Task/Array-concatenation/Scheme/array-concatenation-2.ss

@@ -0,0 +1,25 @@
+(use gauche.array)
+
+(define (print-matrix m)
+  (define row-num #f)
+  (array-for-each-index m
+    (lambda (row col)
+      (when (and row-num (not (= row-num row))) (newline))
+      (format #t "~a " (array-ref m row col))
+      (set! row-num row)))
+  (newline))
+
+(define a
+  #,(<array> (0 3 0 2)
+      a b
+      c d
+      e f))
+
+(define b
+  #,(<array> (0 3 0 2)
+      1 2
+      3 4
+      5 6))
+
+(print-matrix (array-concatenate a b))
+(print-matrix (array-concatenate a b 1))

Task/Array-concatenation/Simula/array-concatenation.simula

@@ -1,50 +1,95 @@
-BEGIN
+BEGIN  ! Concatenate arrays - of REAL, here;
 
-    CLASS ARRAYHOLDER(N); INTEGER N;
+    CLASS REAL_ARRAY(N); INTEGER N;
     BEGIN
         REAL ARRAY DATA(1:N);
-    END;
 
-    REF(ARRAYHOLDER) PROCEDURE CONCAT(A, B); REF(ARRAYHOLDER) A, B;
+        ! Return a new REAL_ARRAY containing
+        ! the values from this REAL_ARRAY
+        ! followed by the values from other;
+        REF(REAL_ARRAY) PROCEDURE CONCAT(other);
+            REF(REAL_ARRAY) other;
+        BEGIN
+            REF(REAL_ARRAY) C;
+            INTEGER I;
+
+            C :- NEW REAL_ARRAY(N + other.N);
+
+            FOR I := 1 STEP 1 UNTIL N DO
+                C.DATA(I) := DATA(I);
+
+            FOR I := 1 STEP 1 UNTIL other.N DO
+                C.DATA(N + I) := other.DATA(I);
+
+            CONCAT :- C;
+        END;
+
+        ! Fill DATA;
+        REF(REAL_ARRAY) PROCEDURE linearFill(start, stride);
+            REAL start, stride;
+        BEGIN
+            linearFillFrom(DATA, 1, N, start, stride);
+            linearFill :- this REAL_ARRAY
+        END;
+
+        PROCEDURE out(sink); REF(printfile) sink;
+        BEGIN
+            INTEGER i;
+            FOR i := 1 STEP 1 UNTIL N DO
+                sink.OUTFIX(DATA(i), 2, 7);
+            sink.OUTIMAGE;
+        END;
+    END REAL_ARRAY;
+
+    ! "The problem" is not array as an input parameter:
+    !  I don't know how to
+    ! "pass a new ARRAY out of a PROCEDURE";
+    REF(REAL_ARRAY) PROCEDURE concatenate(a, b);
+        REAL ARRAY a, b;
     BEGIN
-        REF(ARRAYHOLDER) C;
-        INTEGER I, J;
+        INTEGER i, a_, N, b_, M;
+        REF(REAL_ARRAY) c;
+        a_ := LOWERBOUND(a, 1) - 1;
+        N := UPPERBOUND(a, 1) - a_;
+        b_ := LOWERBOUND(a, 1) - 1;
+        M := UPPERBOUND(b, 1) - b_;
+        c :- NEW REAL_ARRAY(N + M);
 
-        C :- NEW ARRAYHOLDER(A.N + B.N);
+        FOR i := 1 STEP 1 UNTIL N DO
+            c.DATA(i) := a(a_+i);
+        ! for readability, don't
+        !  reduce one index expression to a variable
+        FOR i := 1 STEP 1 UNTIL M DO
+            c.DATA(N + i) := b(b_+i);
 
-        FOR I := 1 STEP 1 UNTIL A.N DO
-        BEGIN
-            J := J+1; C.DATA(J) := A.DATA(I);
-        END;
+        concatenate :- c;
+    END concatenate REAL ARRAYs;
 
-        FOR I := 1 STEP 1 UNTIL B.N DO
-        BEGIN
-            J := J+1; C.DATA(J) := B.DATA(I);
-        END;
-
-        CONCAT :- C;
+    ! two more convenience PROCEDUREs;
+    PROCEDURE linearFillFrom(a, from, inclusive, start, stride);
+            REAL ARRAY a; ! passed by reference;
+            INTEGER from, inclusive;
+            REAL start, stride;
+    BEGIN
+        INTEGER i;
+        FOR i := from STEP 1 UNTIL inclusive DO
+            a(i) := start + stride * (i - from)
     END;
+    PROCEDURE linearFill(a, start, stride);
+            REAL ARRAY a;
+            REAL start, stride;
+        linearFillFrom(a, LOWERBOUND(a, 1), UPPERBOUND(a, 1),
+                       start, stride);
 
-    REF(ARRAYHOLDER) X, Y, Z;
-    INTEGER I;
 
-    X :- NEW ARRAYHOLDER(3);
-    Y :- NEW ARRAYHOLDER(4);
-
-    I := 0;
-    I := I+1; X.DATA(I) := 2*I;
-    I := I+1; X.DATA(I) := 2*I;
-    I := I+1; X.DATA(I) := 2*I;
-
-    I := 0;
-    I := I+1; Y.DATA(I) := -3*I;
-    I := I+1; Y.DATA(I) := -3*I;
-    I := I+1; Y.DATA(I) := -3*I;
-    I := I+1; Y.DATA(I) := -3*I;
-
-    Z :- CONCAT(X, Y);
-    FOR I := 1 STEP 1 UNTIL Z.N DO
-        OUTFIX(Z.DATA(I), 2, 7);
-    OUTIMAGE;
+    REF(REAL_ARRAY) X;
+    REAL ARRAY u(1:3), v(1:4);
+    linearFill(u, 3, 7);
+    linearFill(v, 0, 5);
+    concatenate(u, v).out(SYSOUT);
 
+    X :- NEW REAL_ARRAY(3).linearFill(1, 2);
+    X.out(SYSOUT);
+    X.CONCAT(NEW REAL_ARRAY(4)
+                .linearFill(-1, -3)).out(SYSOUT);
 END.

Task/Array-concatenation/VBA/array-concatenation.vba

@@ -0,0 +1,25 @@
+Option Explicit
+
+Sub MainConcat_Array()
+Dim Aray_1() As Variant, Aray_2() As Variant
+Dim Result() As Variant
+
+    Aray_1 = Array(1, 2, 3, 4, 5, #11/24/2017#, "azerty")
+    Aray_2 = Array("A", "B", "C", 18, "End")
+    Result = Concat_Array(Aray_1, Aray_2)
+    Debug.Print "With Array 1 : " & Join(Aray_1, ", ")
+    Debug.Print "And Array 2 : " & Join(Aray_2, ", ")
+    Debug.Print "The result is Array 3 : " & Join(Result, ", ")
+End Sub
+
+Function Concat_Array(A1() As Variant, A2() As Variant) As Variant()
+Dim TmpA1() As Variant, N As Long, i As Long
+
+    N = UBound(A1) + 1
+    TmpA1 = A1
+    ReDim Preserve TmpA1(N + UBound(A2))
+    For i = N To UBound(TmpA1)
+        TmpA1(i) = A2(i - N)
+    Next
+    Concat_Array = TmpA1
+End Function