From: lito.nicolai@...
Date: 2015-02-23T00:03:22+00:00
Subject: [ruby-core:68232] [Ruby trunk - Bug #10855] [PATCH] Matrix#inverse returns matrix of integers whenever possible

Issue #10855 has been updated by Lito Nicolai.


Hello! Are there any further thoughts or consensus on which path to take with this?

Here are the options:
1. When dividing matrices, if the resulting matrix has any rational numbers in it, it is entirely rational numbers-- 
even if they have a divisor of 1.
2. When dividing matrices, the result can have a mix of numeric types, even though this can result in a mix of 
precise (rational) and imprecise (integral) division in the next operation.
3. Scalar division of a matrix by an integer is patched to return a rational if needed, removing the loss of 
precision, but breaking with the rest of integral division in Ruby.

I'm happy to write up a patch with any of these changes!

Best,
L

Benoit Daloze wrote:
> Lito Nicolai wrote:
> > Marc-Andre Lafortune wrote:
> > > Interesting.
> > > 
> > > I'm thinking it might be best to do the conversion even if some entries are not integral. Why do you feel it's best to have uniform types accross a matrix, in particular when would having an Integer instead of a Rational be a problem?
> 
> It means every operation that follows must go through rational arithmetic which is likely to be slower and more memory hungry, isn't it?
> But of course homogeneity also has its value and the code to lower explicitly Rational to Integer is not exactly nice.
> 
> > In the Matrix class, scalar divison is implemented by using the usual `/`
> > operation, which loses precision on `Integer`s but not on `Rational`s. If
> > the Matrix is a mix of the two, something like this will happen:
> > 
> >     > x = Matrix[[(3/1), 3, 3], [3, (3/1), 3], [3, 3, (3/1)]]
> >     => # as above
> >     > x / 2
> >     => Matrix[[(3/2), 1, 1], [1, (3/2), 1], [1, 1, (3/2)]]
> > 
> > I would find this mixed precision *really* surprising when writing matrix code!
> > Especially because the loss of precision could be hidden across a number
> > of matrix, vector, and scalar multiplications.
> 
> I would think this is a bug. Matrix division by a scalar should be exact, no?



----------------------------------------
Bug #10855: [PATCH] Matrix#inverse returns matrix of integers whenever possible
https://bugs.ruby-lang.org/issues/10855#change-51592

* Author: Lito Nicolai
* Status: Open
* Priority: Normal
* Assignee: Marc-Andre Lafortune
* ruby -v: 2.3.0
* Backport: 2.0.0: UNKNOWN, 2.1: UNKNOWN, 2.2: UNKNOWN
----------------------------------------
Currently, Matrix#inverse returns a matrix of Rationals, even when each
element has a denominator of 1. This leads to 

	> x = Matrix.identity 3
	=> Matrix[[1, 0, 0],
                  [0, 1, 0],
                  [0, 0, 1]]

	> x.inverse
	=> Matrix[[(1/1), (0/1), (0/1)],
		  [(0/1), (1/1), (0/1)],
                  [(0/1), (0/1), (1/1)]]

Even though `Matrix.identity.inverse` should be identical to `Matrix.identity`.

This patch guarantees that Matrix#inverse will return a matrix of integers
whenever it can. To maintain uniform types across a matrix, the conversion 
is only performedif *every* element can be converted to an integer.

---Files--------------------------------
matrix_inverse_to_integer.patch (2.14 KB)


-- 
https://bugs.ruby-lang.org/