From: Paul Lutus <nospam@...>
Date: 2006-09-12T16:35:38+09:00
Subject: Re: Matrix

MonkeeSage wrote:

/ ...

> Anyhow, I don't really care if []= is there by default, I can add it if
> I want it; but I just don't understand why "a matrix [as a value] is
> immutable" means that []= shouldn't be there regarding the data
> structure.

You might as well ask why there is no formal method to change the third
digit of an integer in class Fixnum. The reply would be that integers are
ordinarily dealt with in their entirety, and for special needs, the user of
the class can write custom code to deal with the border cases, but there's
no point in trying to include all the marginal utilities in the formal
class definition.

Most matrix operations operate on matrices as units. Here's an example, a
matrix from my library, responsible for rotating objects in three-space:

---------------------------------------------------

class RotationMatrix

   ToRad = Math::PI / 180.0
   ToDeg = 180.0 / Math::PI
   # perspective depth cue for 3D -> 2D transformation
   PerspectiveDepth = 10.0
   # angular constant for anaglyphic rotation
   AnaglyphScale = 0.03

   # populate 3D matrix with values for x,y,z rotations

   def populate_matrix(xa,ya,za)

      # create trig values
      sx = Math.sin(xa * ToRad);
      cx = Math.cos(xa * ToRad);
      sy = Math.sin(ya * ToRad);
      cy = Math.cos(ya * ToRad);
      sz = Math.sin(za * ToRad);
      cz = Math.cos(za * ToRad);

      # build rotation matrix
      @rot_mat =
      [
         [
            cy * cx - sy * sx * sz,
            - cy * sx - cx * sy * sz,
            cz * sy
         ],
         [
            sx * cz,
            cz * cx,
            sz
         ],
         [
            - cx * sy - sx * sz * cy,
            sx * sy - sz * cx * cy,
            cz * cy
         ]
      ]
   end

   # add perspective to 2D points
   # and perform anaglyph position change if specified

   def convert_3d_to_2d(x,y,z,anaglyph_flag)
      x = (x * (PerspectiveDepth + z))/PerspectiveDepth
      x += z * anaglyph_flag * AnaglyphScale if anaglyph_flag
      y = (y * (PerspectiveDepth + z))/PerspectiveDepth
      return x,y
   end

   # rotate a 3D point using matrix values
   # then project into 2D space

   def rotate_convert(v,anaglyph_flag)
      z = @rot_mat[0][0] * v.z + @rot_mat[0][1] * v.y + @rot_mat[0][2] * v.x
      y = @rot_mat[1][0] * v.z + @rot_mat[1][1] * v.y + @rot_mat[1][2] * v.x
      x = @rot_mat[2][0] * v.z + @rot_mat[2][1] * v.y + @rot_mat[2][2] * v.x
      x,y = convert_3d_to_2d(x,y,z,anaglyph_flag)
      return x,y
   end
end

---------------------------------------------------

In this case, the matrix at the heart of the class is the most economical
way to accomplish the mathematical objective, and there's really no point
in being able to change any of its constituent parts, once it has been
constructed. It would be very easy to modify any single array cell, but
there's simply no point.

I think the writers of the Matrix class realized this, and didn't bother to
include an assignment operator on the ground that it wouldn't have any
general utility.

-- 
Paul Lutus
http://www.arachnoid.com