Fuzion Logo
flang.dev — The Fuzion Language Portal
JavaScript seems to be disabled. Functionality is limited.

array3.fz


# This file is part of the Fuzion language implementation.
#
# The Fuzion language implementation is free software: you can redistribute it
# and/or modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation, version 3 of the License.
#
# The Fuzion language implementation is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
# License for more details.
#
# You should have received a copy of the GNU General Public License along with The
# Fuzion language implementation.  If not, see <https://www.gnu.org/licenses/>.


# -----------------------------------------------------------------------
#
#  Tokiwa Software GmbH, Germany
#
#  Source code of Fuzion standard library feature array(l1,l2,l3)
#
#  Author: Fridtjof Siebert (siebert@tokiwa.software)
#
# -----------------------------------------------------------------------

# array(length0, length1, length2)
#
# array provides three-dimensional immutable arrays. These are actually
# one-dimensional immutable arrays with an additional access function with
# three index parameters.
#
array3<T>(length0, length1, length2 i32,
          init3 (i32, i32, i32) -> T)
 : array<T> (sys.array<T> length0*length1*length2)
  pre
    safety: length0 >= 0,
    safety: length1 >= 0,
    safety: length2 >= 0,
    safety: length0 *? length1 *? length2 >=? 0
is


  # indices range in first dimension
  #
  indices0 => 0..length0-1


  # indices range in second dimension
  #
  indices1 => 0..length1-1


  # indices range in third  dimension
  #
  indices2 => 0..length2-1


  for i1 in 0..length0-1 do
    for i2 in 0..length1-1 do
      for i3 in 0..length2-1 do
        internalArray[(i1 * length1 + i2) * length2 + i3] := init3 i1, i2, i3

  index [ ] (i0, i1, i2 i32) T
    pre
      safety: 0 <= i0 < length0,
      safety: 0 <= i1 < length1,
      safety: 0 <= i2 < length2
  is
    array3.this[(i0 * length1 + i1) * length2 + i2]


  # create a string representation of this array including all the string
  # representations of its contents, separated by ',' and enclosed in '['
  # and ']'.  Arrays in inner dimensions are grouped using '[' and ']'.
  #
  redef asString =>
    "[{for
         s := "", s + c + u
         i0 in indices0
         c := "", ","
         u := "[{for
                   s2 := "", s2 + c2 + (slice from to)
                   i1 in indices1
                   c2 := "", ","
                   from := ((i0 * length1 + i1) * length2)
                   to := from + length2
                 else
                   s2
                }]"
       else
         s
      }]"



  # get a list of tuples indices and elements in this array
  #
  enumerate3 list<tuple<i32, i32, i32, T>> is
    if length == 0
      nil
    else
      enumerate3Cons 0 0 0


  # create a cons cell for a list of tuples of this array's indices and elements
  # starting at the given indices.
  #
  enumerate3Cons (i, j, k i32) : Cons<tuple<i32, i32, i32, T>, list<tuple<i32, i32, i32, T>>>
    pre
      debug: 0 <= i < length0,
      debug: 0 <= j < length1,
      debug: 0 <= k < length2
  is
    head => (i, j, k, index[] i j k)
    tail list<tuple<i32, i32, i32, T>> is
      if      k < length2-1 then enumerate3Cons i   j   k+1
      else if j < length1-1 then enumerate3Cons i   j+1 0
      else if i < length0-1 then enumerate3Cons i+1 0   0
      else                       nil