On Fri, Oct 14, 2011 at 4:12 PM, Gilles Sadowski <
gil...@harfang.homelinux.org> wrote:
> Hello.
>
> >
> > I believe that the BlockMatrix approach you have taken is actually quite
> > good and might yield a bit more stable optimization improvement than
> simple
> > loop unrolling. Consider operations on non-overlapping blocks. You could
> > easily dispatch those in parallel. I agree that it is a bit painful to
> use,
> > but in solver (for example) it is very quick. I would not be quick to
> > dispatch it. Its taken me a couple of months to appreciate its subtle
> > elegance. There is many more tricks you can play with your approach.
> Also,
> > don't forget the timings they present are for one very specific
> > operation-one where the block approach is at a slight disadvantage.
> >
> > One place where the Open Gamma approach is better is using single
> dimension
> > arrays, but that's not compatible with your block approach. If you
> recall, I
> > asked to add a SymmetricMatrix implementation storing the data in a
> single
> > dimension array with compressed row major storage. That proposal was not
> > well received.
>
> I might have missed the goal of your proposal but I think that main point
> of the discussion had been about having a separate class for operations. I
> don't recall that a new implementation ("SymmetricMatrix") with a
> specifically optimized storage was not approved.
>
> In fact, it has been a few weeks that I wanted to ask whether someone would
> be interested in providing a symmetric matrix; the primary motivation for
> me
> would be that it will simplify some code in "BOBYQAOptimizer".
> I see no reason why you would not be welcome to create a new
> "SymmetricMatrix" class.
>
> I would be delighted to collaborate. The proposal was not denied, but the
response was overwhelmingly negative. Perhaps we can start a new discussion
so I don't start top posting... ;-) As I mentioned already, I am very
impressed by BOBYQA.
> I suspect when the time comes to debate 'their' approach with
> > the commons approach the same issues will crop up.
> >
> > On other aspects, the group will not like use of factories. They seem to
> be
> > everywhere in the code. Again, there is reticence in this community with
> > respect to non constructor construction.
>
> This is not an accurate summary of the discussion we had on that subject.
> The point (mine, at least) was not that we should or should not use
> factories; it was that we should not mix both styles. As it happens, the
> codebase is currently written with the "explicit" construction style (and
> the rare uses of factories that still existed in 2.2 were not appropriate
> IMHO), so the argument went that the proponents of factories did not
> provide
> explicit examples of why the codebase should be moved to another paradigm
> (I
> recall people only saying: "I like factories").
>
I only noted the reluctance. I used 2.1 very sparingly and cannot recall
what factories existed.
> Finally, I can connect this with what you report about "OpenGamma" being a
> framework for finance computations; the keyword is "framework" which CM is
> not: It's "just" a low-level library, a collection of algorithms not
> targetted toward a specific application domain. My impression is that is
> much easier to get the framework wrong for CM (meaning: not appropriate for
> certain uses of those low-level tools).
>
Yes, the Open Gamma project has elements of low level library like CM
(certain packages could be removed from their jar and put into a separate
jar). It also has a messaging, calculation, information folding (like olap)
which are definitely more framework type components. I am very surprised by
the completeness. Most trading desks don't have access to such comprehensive
systems.
> Regards,
> Gilles
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: dev-unsubscr...@commons.apache.org
> For additional commands, e-mail: dev-h...@commons.apache.org
>
>
Additionally, I was hoping you would give your thoughts on the BlockMatrix
design.
-Greg
