commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Gilles Sadowski <gil...@harfang.homelinux.org>
Subject Re: [math] Exceptions for matrix operations
Date Tue, 10 May 2011 13:56:08 GMT
> > [...]
> > > In fact, such an exception would be raised if the program stumbles
> > > upon to vectors x and y such as x'Ay differs from y'Ax. So, the
> > > existing NonSymmetricMatrixException would be a particular case of a
> > > more general (BasicNonSymetricMatrixException ?), with x = ei and y
> > > = ej. In this case, the meaning of the tolerance would be the same
> > > for both exceptions.
> > > >So, messy as it is, I agree with
> > > >Gilles that the best solution is to have both forms of witnessed
> > > >exceptions derive from a common base.  So, for example,
> > > >NonSymmetricMatrixException has something like
> > > >MatrixSymmetryException and SymmetricOperationException as subclasses.
> > > >
> > > So maybe instead of creating two new exceptions, maybe one would be
> enough?
> > > BasicNonSymmetricMatrixException
> > >   +--NonSymmetricMatrixException
> > >
> > > Imagine for a moment we go for this solution. Then it would be nice
> > > (for debugging purposes), to be able to retrieve x and y from
> > > BasicNonSymmetricMatrixException. These vectors would however
> > > presumably be huge, so it's out of the question to print them in the
> > > error message. They should just be available, which requires to
> > > create new getters.
> >
> > That those getters will be defined in "BasicNonSymmetricMatrixException"
> > but won't be initialized in "NonSymmetricMatrixException", is another
> > reason for having two distinct exceptions deriving from a common base
> class.
> 
> I don't agree there: these getters are still meaningful in
> "NonSymmetricMatrixException". For the sake of the argument, let's call them
> getFirstOffendingVector and getSecondOffendingVector. If
> NonSymmetricMatrixException is raised by
> |a[i,j] - a[j,i]| > tol,
> then
>   - getFirstOffendingVector could return (construct) ei = [0, ..., 1, ..., 0]
> (i-th component is the only non-zero value)
>   - similarly, getSecondOffendingVector could return (construct) ej.
> On top of that, NonSymmetricMatrixException would still implement getRow(),
> getColumn(), while the base class BasicSymmetricMatrixException would only
> implement getFirstOffendingVector and getSecondOffendingVector.
> 
> In this case, getRow() and getColumn() make the more general methods
> getFirstOffendingVector and getSecondOffendingVector pretty much pointless,
> but *not meaningless*.

The question is thus: Is it OK to provide pointless methods?
I also wonder whether it is reasonable to _generate_ state variables just
so that the accessors can return them.
Usually, when a exception is constructed, it is _passed_ data that provide
the context of the failure (i.e. the vectors or the indices that show the
problem).
In this case, if the test (that triggered the exception) was not performed
using vectors, it looks quite strange to be able to retrieve vectors...


Gilles

---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org


Mime
View raw message