#15820: Implement sequences of bounded integers
--------------------------------------------+------------------------
Reporter: SimonKing | Owner:
Type: enhancement | Status: new
Priority: major | Milestone: sage-6.2
Component: algebra | Resolution:
Keywords: sequence bounded integer | Merged in:
Authors: | Reviewers:
Report Upstream: N/A | Work issues:
Branch: | Commit:
Dependencies: | Stopgaps:
--------------------------------------------+------------------------
Comment (by SimonKing):
Hi Nathann,
Replying to [comment:21 ncohen]:
> What I thought you intended was to write a very low-level data structure
somewhere in the misc/ folder.
I somehow do.
> The kind of stuff that one does not use by mistake,
Why? It should be a replacement for tuples (thus, low-level), but it
should ''ideally'' be (close to) a drop-in replacement (thus, it doesn't
matter whether one uses it by mistake).
> Then, I thought you would have a higher-level algebraic stuff with
parents colors and blinking lights that would check their input indeed,
and be what we want a user-friendly object to be.
Again ''ideally'': Blinking colours should only be added when one really
implements paths in quivers.
> But I actually have only one question: I don't know how you intend to
use all this in the end, but I got the impression that several functions
may have to generate a LOT of paths in order to compute some small data,
and throw all the paths away once the computations have ended. Do you want
do create high-level objects in those functions or not ?
Good point. So, you mean that these functions should actually ''not''
create fully-fledged quiver paths, but should just operate on instances of
`BoundedIntegerSequence`, and only in the end interpret them as paths,
when the battle smoke has vanished.
> And so I thought that you high-level objects would have a variable which
would be this low-level object, etc, etc...
Yes, probably that's better.
So, perhaps I should really do `cdef class BoundedIntegerSequence(tuple)`
rather than `cdef class BoundedIntegerSequence(MonoidElement)`.
But then, what to do with all these internally used constants that are
needed even for the low-level functionality of `BoundedIntegerSequence`?
Would you prefer to compute and store these constants 10000 times when
creating 10000 sequences of integers bounded by `B`? Or would you prefer
to compute and store these constants only once, namely in a parent that
hosts all sequences of integers with a fixed bound?
Or do you have a third solution for storing/accessing these constants
efficiently?
--
Ticket URL: <http://trac.sagemath.org/ticket/15820#comment:22>
Sage <http://www.sagemath.org>
Sage: Creating a Viable Open Source Alternative to Magma, Maple, Mathematica,
and MATLAB
--
You received this message because you are subscribed to the Google Groups
"sage-trac" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/sage-trac.
For more options, visit https://groups.google.com/groups/opt_out.
