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

matrix.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 matrix
#
#  Author: Fridtjof Siebert (siebert@tokiwa.software)
#
# -----------------------------------------------------------------------

# matrix -- matrix based on arbitrary numeric type
#
# matrix provides matrix operations based on an arbitray numeric type
#
matrix(redef M (numeric M).type, e array2 M) : numeric (matrix M), matrices M
is

# private:

  # just for brevity
  a => matrix e

# public:

  # enable generic features in ancestors
  redef thiz => a
  redef orderedThis => a

  # basic operations
  redef prefix + => a
  redef infix +  (b matrix M) => matrix (array2 M e.length0 e.length1 i,j->e[i,j]+b.e[i,j])
  redef infix -  (b matrix M) => matrix (array2 M e.length0 e.length1 i,j->e[i,j]-b.e[i,j])
  redef infix *  (b matrix M) =>
    matrix (array2 M e.length0 b.e.length1
                   (i,j ->
                     for
                       v := e[0,0].zero, v+f
                       x in e.indices1
                       f := a.e[i,x]*b.e[x,j]
                     else
                       v
                     ))
  redef infix /  (b matrix M) matrix M
    pre
      safety: false
  is
    panic "'matrix.infix /' not defined."

  # comparison
  redef infix == (b matrix M) =>
    for
      x in e
      y in a.e
    until x /= y
      false
    else
      true

  redef infix != (b matrix M) => !(a = b)

  # NYI: total order
  redef infix <  (b matrix M) => panic "matrix does not define a total order"
  redef infix <= (b matrix M) => panic "matrix does not define a total order"
  redef infix >  (b matrix M) => panic "matrix does not define a total order"
  redef infix >= (b matrix M) => panic "matrix does not define a total order"

  transpose matrix M is
    matrix (array2 M e.length1 e.length0 i,j->e[j,i])

  redef asString => e.asString

  # NYI: these three should be implemented in matrices, not here:
  redef zero => panic "matrix.zero not implemented"
  redef one  => panic "matrix.one not implemented"

  # NYI: 'matrix' misses imlementaton of many abstract features from
  # 'numeric'. Maybe 'matrix' should not inherit from 'numeric' at all?


# matrices -- unit type defining features related to matrix
#
# matrices is a unit type defining features related to matrix but not
# requiring an instance.
#
matrices(M numeric M.type) : numerics (matrix M) is

  redef name => "matrix"

  # NYI: There is currently no easy way to get hold of an instance of the unit
  # type corresponding to E.
  #
  #   redef zero => matrix E.zero E.zero
  #   redef one  => matrix E.one  E.zero
  #
  # dummy implementations:
  redef zero => panic "NYI: matrices.zero not implemented, needs to instantiate type arg E"
  redef one  => panic "NYI: matrices.one not implemented, needs to instantiate type arg E"