Velocity Reviews > Ruby > Matrix

# Matrix

MonkeeSage
Guest
Posts: n/a

 09-12-2006
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
Guest
Posts: n/a

 09-12-2006
On 9/11/06, MonkeeSage <(E-Mail Removed)> 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...

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.

--
Rick DeNatale

My blog on Ruby

ara.t.howard@noaa.gov
Guest
Posts: n/a

 09-12-2006
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...

http://narray.rubyforge.org/

and it even dovetails with

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

you can go back and forth.

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

ara.t.howard@noaa.gov
Guest
Posts: n/a

 09-12-2006
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.

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

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

Just Another Victim of the Ambient Morality
Guest
Posts: n/a

 09-12-2006

"MonkeeSage" <(E-Mail Removed)> wrote in message
news:(E-Mail Removed) ups.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?

MonkeeSage
Guest
Posts: n/a

 09-12-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.

Hmm, I guess I wasn't clear, because that was my point (and another
person also didn't understand me). My point was that n can be
destructively altered by assignment, but its value (1) cannot be. So
even though a particular matrix (as a value) is immutible and unique, a
matrix (as a concept, viz., the data structure, it's reference) need
not be. Given matrix r, represented simply as a dimensional array:

r = [
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]
]

What would be the difference between:

n = 1
n = n + 1

And:

r[1][1] = r[1][1] + 1

You have a new matrix (as a value), so you're not violating identity,
but you keep the same data structure by destructive assignment ([]=),
rather than creating a new one with the new value in row 1, column 1.

That can easily be added, as was mentioned above, but the rationale for
it not being there is what doesn't make sense to me. The rationale is
that a matrix (as a value) is immutable and unique; but so are regular
integers and that doesn't hinder their "container" (i.e., a reference)
from being mutable. We don't have to construct a new variable every
time we transform an integer to a different integer; why should a
member of matrix be any different and require a new matrix to be
constructed rather than allowing the reference to the member to be
destructively modified?

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.

Regards,
Jordan

Michael Ulm
Guest
Posts: n/a

 09-12-2006
Paul Lutus wrote:

> 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:
>

--snip--
>
> 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.
>

Then they would have been wrong. The lack of the []= operator has been a
major PITA for me, as I often need matrix functions (FWIW I'm a
mathematician, working on applications of artificial inteligence).
The implementations of many higher level matrix operations needs the
assignment operator. Try implementing a SVD algorithm without it.

Regards,

Michael

--
Michael Ulm
R&D Team
ISIS Information Systems Austria
tel: +43 2236 27551-219, fax: +43 2236 21081
e-mail: http://www.velocityreviews.com/forums/(E-Mail Removed)

---------------------------------------------------------------
This e-mail is only intended for the recipient and not legally
binding. Unauthorised use, publication, reproduction or
disclosure of the content of this e-mail is not permitted.
This email has been checked for known viruses, but ISIS accepts
no responsibility for malicious or inappropriate content.
---------------------------------------------------------------

Michael Ulm
Guest
Posts: n/a

 09-12-2006
Just Another Victim of the Ambient Morality wrote:

> "MonkeeSage" <(E-Mail Removed)> wrote in message
> news:(E-Mail Removed) ups.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?
>
>

I think he's trying to say, that there is no rational reason for
leaving out the []= operator, and I agree.

Regards,

Michael

--
Michael Ulm
R&D Team
ISIS Information Systems Austria
tel: +43 2236 27551-219, fax: +43 2236 21081
e-mail: (E-Mail Removed)

---------------------------------------------------------------
This e-mail is only intended for the recipient and not legally
binding. Unauthorised use, publication, reproduction or
disclosure of the content of this e-mail is not permitted.
This email has been checked for known viruses, but ISIS accepts
no responsibility for malicious or inappropriate content.
---------------------------------------------------------------

Dave Burt
Guest
Posts: n/a

 09-12-2006
Michael Ulm wrote:
> Just Another Victim of the Ambient Morality wrote:
>
>> "MonkeeSage" <(E-Mail Removed)> wrote in message
>> 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?
>>
>>

>
> I think he's trying to say, that there is no rational reason for
> leaving out the []= operator, and I agree.

The benefit is that you can assume no other code is modifying your matrix.

n = Matrix.I(2)
some_function(n)
p n # same as before

It's a good feature.

[]= would be useful, too, but I think to keep the immutability a better
addition that provides the same functionality could be provided; a
modified_at(x,y,value) method or something, but naming it is hard.

Cheers,
Dave

William Crawford
Guest
Posts: n/a

 09-12-2006
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/.