>> I understand that you somehow want a more efficient datastructure for integer
>> partitions, but if that is all, then it is not worth the trouble.

> I disagree, at least slightly. If it's just a little overhead, OK. But the
> algorithm for generating integer partitions is probably a lot faster.

So, you should use the faster algorithm. But that does *not* mean that 
you have to export that special data structure to the outside world.

> There is a second issue: If we only implement MultiSetPartitions, then we can
> only provide an efficient coercion to MultiSet MultiSet Integer. To get a
> SetSpecies SetSpecies Integer, we first have to check that we really have a
> SetPartition. And so on.

I think, I was aware of this when I wrote

http://sourceforge.net/mailarchive/message.php?msg_id=37814844

in particular the part that starts with ...


    So for the design of AC I would like to propose the following.

    structures: List L -> Generator %
    isomorphismTypes: List L -> Generator %

    with the following interpretation:

Would that fit your needs?


>> I have reasons to avoid an extra IsomorphismType domain/category.
>>
>> 1) It makes the code more complicated.
> 
> But you can generate isomorphismtypes of compositions now. As far as I know,
> MuPAD Combinat only does special cases. Same holds for the Derivative, and for
> Pointing, I think.

I hope, Martin, you understand me correctly. I don't have something 
against including the computation of iso types. I worry about the design 
of the code.

>> 2) you don't gain anything if you work with decomposable structures
>> (Look at how you build the IsomorphismType for Plus and Times.)

> I don't understand exactly what you mean here. The code for isomorphismTypes
> may look similar, but it's doing something quite different.

No that is not what I mean. I meant that

<<representation: Times>>=
Rep == Record(tag: Subset L, left: F L, right: G L);
@

<<representation: MultiTimes>>=
Rep == Record(
     tag: MultiSubset L,
     left: IsomorphismType$(F L),
     right: IsomorphismType$(G L)
);
@

are actually very much the same construction, ie, you get a record of 3 
things. So the argument of getting more efficient data structures does 
not apply for MultiPlus, MultiTimes, MultiCompose. For me it just looks 
like doubling code. And further, I would guess, that the current 
compiler has problems with using a domain exported by another domain.

There must be something better.

Ralf

-------------------------------------------------------------------------
Take Surveys. Earn Cash. Influence the Future of IT
Join SourceForge.net's Techsay panel and you'll get the chance to share your
opinions on IT & business topics through brief surveys - and earn cash
http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
_______________________________________________
Aldor-combinat-devel mailing list
Aldor-combinat-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/aldor-combinat-devel

Reply via email to