Matrix

ruby-talk
1

Hi all,
a) Is there a way to create a non-square matrix in ruby?
b) How does one set any arbitrary element of an array?

I searched for these bu there was a post about 3 years back, if
anything has been done it would be better to use that rather than
something i should write!
Thanks
krishnan

2

Hi --

···

On Mon, 11 Sep 2006, v.srikrishnan@gmail.com wrote:

Hi all,
a) Is there a way to create a non-square matrix in ruby?
b) How does one set any arbitrary element of an array?

I searched for these bu there was a post about 3 years back, if
anything has been done it would be better to use that rather than
something i should write!

Check out the Matrix class -- look for matrix.rb in the Ruby
distribution.

David

--
                   David A. Black | dblack@wobblini.net
Author of "Ruby for Rails" [1] | Ruby/Rails training & consultancy [3]
DABlog (DAB's Weblog) [2] | Co-director, Ruby Central, Inc. [4]
[1] Ruby for Rails | [3] http://www.rubypowerandlight.com
[2] http://dablog.rubypal.com | [4] http://www.rubycentral.org

3

Hi all,
a) Is there a way to create a non-square matrix in ruby?

Another poster has answered this one.

b) How does one set any arbitrary element of an array?

Like this:

···

v.srikrishnan@gmail.com wrote:

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

#! /usr/bin/ruby

size = 9

# create, preset value

array = Array.new(size) { Array.new(size) {"."} }

# change one value

array[4][4] = '*'

# show it

array.each do |b|
   b.each do |i|
      print b[i]
   end
   puts ""
end

Output:

.........
.........
.........
.........
....*....
.........
.........
.........
.........

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

4

dblack@wobblini.net wrote:

Hi --

Hi all,
a) Is there a way to create a non-square matrix in ruby?
b) How does one set any arbitrary element of an array?

I searched for these bu there was a post about 3 years back, if
anything has been done it would be better to use that rather than
something i should write!

Check out the Matrix class -- look for matrix.rb in the Ruby
distribution.

David

You can only set an arbitrary element of a Matrix when it is created.
Once created, you can't change any of the entries.

···

On Mon, 11 Sep 2006, v.srikrishnan@gmail.com wrote:

5

Thanks everyone. I had seen the same answers in the post i mentioned
(2-3 yrs now i think). i was wondering why these small things had not
been added. In my humble opinion having these small things in the basic
Matrix class would be helpful to beginners. I do not say that the basic
class should have numerical stuff like SVD, LU decomposition or other
linear algebra stuff etc. but these things would help. Also,if someone
wants to "freeze" a matrix i think ruby has an operation for it(am
learning ruby).

Thanks again
krishnan
Paul Lutus wrote:

···

v.srikrishnan@gmail.com wrote:

> Hi all,
> a) Is there a way to create a non-square matrix in ruby?

Another poster has answered this one.

> b) How does one set any arbitrary element of an array?

Like this:

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

#! /usr/bin/ruby

size = 9

# create, preset value

array = Array.new(size) { Array.new(size) {"."} }

# change one value

array[4][4] = '*'

# show it

array.each do |b|
   b.each do |i|
      print b[i]
   end
   puts ""
end

Output:

.........
.........
.........
.........
....*....
.........
.........
.........
.........

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

6

"M. Edward (Ed) Borasky" <znmeb@cesmail.net> wrote in message
news:4504A5A6.9050900@cesmail.net...

Hi --

Hi all,
a) Is there a way to create a non-square matrix in ruby?
b) How does one set any arbitrary element of an array?

I searched for these bu there was a post about 3 years back, if
anything has been done it would be better to use that rather than
something i should write!

Check out the Matrix class -- look for matrix.rb in the Ruby
distribution.

You can only set an arbitrary element of a Matrix when it is created.
Once created, you can't change any of the entries.

    The = operator does seem conspicuously missing. If anyone knows why
this was (obviously) deliberately left out, please say something!

    Of course, if this is useful to you, you can always add it, yourself!
I think it would go something like this...

require 'matrix'

class Matrix # are for kids!
    def = (i, j, v)
        @rows[i][j] = v
    end
end

···

dblack@wobblini.net wrote:

On Mon, 11 Sep 2006, v.srikrishnan@gmail.com wrote:

7

Just Another Victim of the Ambient Morality wrote:

You can only set an arbitrary element of a Matrix when it is created.
Once created, you can't change any of the entries.

    The = operator does seem conspicuously missing. If anyone knows why
this was (obviously) deliberately left out, please say something!

It's by design. A Matrix is immutable, like Ruby's other numbers
(Fixnum, Rational, Complex...)

Consider subclassing rather than modifying the base class for this reason.

class MutableMatrix < Matrix
  def = ...

Cheers,
Dave

···

"M. Edward (Ed) Borasky" <znmeb@cesmail.net> wrote

8

Just Another Victim of the Ambient Morality wrote:

/ ...

You can only set an arbitrary element of a Matrix when it is created.
Once created, you can't change any of the entries.

    The = operator does seem conspicuously missing. If anyone knows why
this was (obviously) deliberately left out, please say something!

Matrices are meant to be operated on as units, not by manipulating the
contents of individual cells. Think of a matrix as a datatype, a complete,
self-contained entity, one you can create or destroy in its entirety.

BTW, in answer to an earlier question:

a) Is there a way to create a non-square matrix in ruby?

#! /usr/bin/ruby

require 'matrix'

m = Matrix[[1,2,3],[4,5,6],[7,8,9]]

nsqm = Matrix[[1,2,3],[7,8,9]]

puts m,nsqm

Matrix[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Matrix[[1, 2, 3], [7, 8, 9]]

Of course, if this is useful to you, you can always add it, yourself!
I think it would go something like this...

require 'matrix'

class Matrix # are for kids!
    def = (i, j, v)
        @rows[i][j] = v
    end
end

Yes, this works as expected. Easy enough to add if you really want it. :slight_smile:

···

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

9

Dave Burt wrote:

It's by design. A Matrix is immutable, like Ruby's other numbers
(Fixnum, Rational, Complex...)

Why should a Matrix be immutable? It's not a type like a Fixnum, it's a
data structure, like an Array or Hash. What is gained by creating a new
Matrix from a changing data stream, rather than updating an existing
one?

Regards,
Jordan

10

MonkeeSage wrote:

Dave Burt wrote:

It's by design. A Matrix is immutable, like Ruby's other numbers
(Fixnum, Rational, Complex...)

Why should a Matrix be immutable? It's not a type like a Fixnum, it's a
data structure, like an Array or Hash. What is gained by creating a new
Matrix from a changing data stream, rather than updating an existing
one?

In mathematics, matrices of various kinds are regarded as a unit, usually
indivisible. For example, they're used a lot in computer graphics
processing to hold rotation matrices.

The rotation matrices are loaded with specific values that accomplish
rotations and translations, and until the computed viewpoint changes, the
entire matrix is used to process all the image vertices.

Then, when the viewpoint changes, the entire matrix is recomputed, and a new
immutable matrix is created. The point I am making is that the matrix can't
function if it is thought of as nine scalar values rather than a 3x3 square
matrix.

···

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

11

Paul Lutus wrote:

The point I am making is that the matrix
can't
function if it is thought of as nine scalar values rather than a 3x3
square
matrix.

I think the point they are making is that not everyone uses matrixes for
the same thing. I agree that for most applications, they should be
treated as immutable. But they are saying that they not only think they
should be modifyable, but that they need them to be modifyable to be
useful to them under their circumstances.

···

--
Posted via http://www.ruby-forum.com/\.

12

Paul Lutus wrote:

MonkeeSage wrote:

Dave Burt wrote:

It's by design. A Matrix is immutable, like Ruby's other numbers
(Fixnum, Rational, Complex...)

Why should a Matrix be immutable? It's not a type like a Fixnum, it's a
data structure, like an Array or Hash. What is gained by creating a new
Matrix from a changing data stream, rather than updating an existing
one?

In mathematics, matrices of various kinds are regarded as a unit, usually
indivisible. For example, they're used a lot in computer graphics
processing to hold rotation matrices.

The rotation matrices are loaded with specific values that accomplish
rotations and translations, and until the computed viewpoint changes, the
entire matrix is used to process all the image vertices.

Then, when the viewpoint changes, the entire matrix is recomputed, and a new
immutable matrix is created. The point I am making is that the matrix can't
function if it is thought of as nine scalar values rather than a 3x3 square
matrix.

The immutability of a Matrix violates Whoever's Law, which states

It is possible to write Fortran programs in any language.

<ducking>

Seriously, though, I agree with the poster who said some mathematicians
want to be able to compute and change elements of a matrix. I happen to
be one of those, and the subclass trick someone posted is one I'll need
to use if I use the "Matrix" concept in my Ruby code. Given how slow it
is, though, that seems unlikely.

13

William Crawford wrote:

Paul Lutus wrote:

The point I am making is that the matrix
can't
function if it is thought of as nine scalar values rather than a 3x3
square
matrix.

I think the point they are making is that not everyone uses matrixes for
the same thing. I agree that for most applications, they should be
treated as immutable. But they are saying that they not only think they
should be modifyable, but that they need them to be modifyable to be
useful to them under their circumstances.

If you want a matrix-like data structure (rather than a mathematical
matrix), why not use an array of arrays?

Cheers, Dave

14

Dave Burt wrote:

If you want a matrix-like data structure (rather than a mathematical
matrix), why not use an array of arrays?

A mathematical matrix is just a dimensional arrangement of data into
"rows" and "columns", thus allowing for certain algorithmic
relationships to be defined and applied (e.g., canonical
decompositions). Every matrix (i.e., the actual matrix considered as a
complex value) is immutable and has a unique identity, just like every
number -- that's true -- but they can also be permuted or otherwise
transformed into different matrices. Why should one have to do that
constructively (i.e., construct a new matrix "from scratch"), rather
than destructively (i.e., change the existing matrix "in place"). Think
of it like this: n = 1; n = n + 1 -- even though the number 1 is
immutable and has a unique identity, the reference to it is not, and
can thus be destructively altered by assignment with the result that it
refers to new identity. It would be a pain to have to do o = n + 1, p =
n + 2 (i.e., creating new references every time the data changes), just
because 1 is immutable. Why should a matrix be any different? Mabye I'm
missing something...

15

Dave Burt wrote:

If you want a matrix-like data structure (rather than a mathematical
matrix), why not use an array of arrays?

Because then I'd have to write all the matrix functions to go along with
them.

···

--
Posted via http://www.ruby-forum.com/\.

16

Yes, you're missing the distinction between a variable which
references a sequence of objects over time, and the objects it
references.

a = 1
a = 2

Does NOT change 1 to 2.

Fortran II used to let you change 1 to 2:

subroutine a(arg)
   arg = 2
end subroutine a

call a(1)

But this was considered a bug and was changed in Fortran IV.

···

On 9/11/06, MonkeeSage <MonkeeSage@gmail.com> wrote:

Dave Burt wrote:
> If you want a matrix-like data structure (rather than a mathematical
> matrix), why not use an array of arrays?

A mathematical matrix is just a dimensional arrangement of data into
"rows" and "columns", thus allowing for certain algorithmic
relationships to be defined and applied (e.g., canonical
decompositions). Every matrix (i.e., the actual matrix considered as a
complex value) is immutable and has a unique identity, just like every
number -- that's true -- but they can also be permuted or otherwise
transformed into different matrices. Why should one have to do that
constructively (i.e., construct a new matrix "from scratch"), rather
than destructively (i.e., change the existing matrix "in place"). Think
of it like this: n = 1; n = n + 1 -- even though the number 1 is
immutable and has a unique identity, the reference to it is not, and
can thus be destructively altered by assignment with the result that it
refers to new identity. It would be a pain to have to do o = n + 1, p =
n + 2 (i.e., creating new references every time the data changes), just
because 1 is immutable. Why should a matrix be any different? Mabye I'm
missing something...

--
Rick DeNatale

My blog on Ruby
http://talklikeaduck.denhaven2.com/

17

http://narray.rubyforge.org/

and it even dovetails with

http://rb-gsl.rubyforge.org/

you can go back and forth.

-a

···

On Tue, 12 Sep 2006, MonkeeSage wrote:

Dave Burt wrote:

If you want a matrix-like data structure (rather than a mathematical
matrix), why not use an array of arrays?

A mathematical matrix is just a dimensional arrangement of data into
"rows" and "columns", thus allowing for certain algorithmic
relationships to be defined and applied (e.g., canonical
decompositions). Every matrix (i.e., the actual matrix considered as a
complex value) is immutable and has a unique identity, just like every
number -- that's true -- but they can also be permuted or otherwise
transformed into different matrices. Why should one have to do that
constructively (i.e., construct a new matrix "from scratch"), rather
than destructively (i.e., change the existing matrix "in place"). Think
of it like this: n = 1; n = n + 1 -- even though the number 1 is
immutable and has a unique identity, the reference to it is not, and
can thus be destructively altered by assignment with the result that it
refers to new identity. It would be a pain to have to do o = n + 1, p =
n + 2 (i.e., creating new references every time the data changes), just
because 1 is immutable. Why should a matrix be any different? Mabye I'm
missing something...

--
in order to be effective truth must penetrate like an arrow - and that is
likely to hurt. -- wei wu wei

18

"MonkeeSage" <MonkeeSage@gmail.com> wrote in message
news:1158024640.933843.82830@i42g2000cwa.googlegroups.com...

Dave Burt wrote:

If you want a matrix-like data structure (rather than a mathematical
matrix), why not use an array of arrays?

A mathematical matrix is just a dimensional arrangement of data into
"rows" and "columns", thus allowing for certain algorithmic
relationships to be defined and applied (e.g., canonical
decompositions). Every matrix (i.e., the actual matrix considered as a
complex value) is immutable and has a unique identity, just like every
number -- that's true -- but they can also be permuted or otherwise
transformed into different matrices. Why should one have to do that
constructively (i.e., construct a new matrix "from scratch"), rather
than destructively (i.e., change the existing matrix "in place"). Think
of it like this: n = 1; n = n + 1 -- even though the number 1 is
immutable and has a unique identity, the reference to it is not, and
can thus be destructively altered by assignment with the result that it
refers to new identity. It would be a pain to have to do o = n + 1, p =
n + 2 (i.e., creating new references every time the data changes), just
because 1 is immutable. Why should a matrix be any different? Mabye I'm
missing something...

    As far as I can tell, matrices are no different. Your example shows
that 1 is immutable but references to it can be re-assigned, so you can do:

n = 3
n = n + 1

    Matrices are no different and, so, you can do:

n = Matrix.scalar(2, 3)
n = n + Matrix.I(2)

    In both cases, the "number" types are immutable but the references to
them are not, as you say. They both work exactly the same way. What are
you trying to say?

19

William Crawford wrote:

Dave Burt wrote:

If you want a matrix-like data structure (rather than a mathematical
matrix), why not use an array of arrays?

Because then I'd have to write all the matrix functions to go along with
them.

Or NMatrix then:

http://narray.rubyforge.org/

Cheers,
Dave

20

but wouldn't it make to days go quickly! nothing beats debuggin to burn up
the clock... perhaps and RCR?

-a

···

On Tue, 12 Sep 2006, Rick DeNatale wrote:

Yes, you're missing the distinction between a variable which
references a sequence of objects over time, and the objects it
references.

a = 1
a = 2

Does NOT change 1 to 2.

Fortran II used to let you change 1 to 2:

subroutine a(arg)
arg = 2
end subroutine a

call a(1)

But this was considered a bug and was changed in Fortran IV.

--
in order to be effective truth must penetrate like an arrow - and that is
likely to hurt. -- wei wu wei