Travis has is writing a nice patch #13605 which implements global options for partitions. Among other things, these options determine how partitions are printed (as lists, using exponential notation, compactly, ...), whether diagrams follow the English or French conventions, whether the default ordering is the lexicographic or dominance etc.
I have been bugging him with suggestions and requests, of which the main ones are: - each option should be accessible as an individual method - the naming of these methods should systematic to make it easier for other classes, which may themselves have options, to easily access these methods. As a result of these discussions I'd like to suggest a general frameworkfor implementing global options for element classes which are controlled by their parents (being a parent myself I am of course advocating for parental control here!:). The reason for this post is to ask whether need a general options mechanism for element classes and, if so, is anyone in favour of the approach described below. The main idea is that the parent inherits a generic method (see below) of the form: def options(self, *option, **options): r""" Print and set options for the element class of ``self`` """" .... which is used to set and print the options for the element class. In the element_class the options to the method ``foo`` are methods of the form ``foo_option1``, ``foo_option2`` and so on. What the ``options`` method of the parent does is simply set ``self.element.foo`` equal to the desired option. The nice thing about this, is that the options do not add extra overhead to the methods and they can be added to the element class simply by adding appropriate methods: def _repr__fuzzy(self): return 'I am fuzzy' def _repr__focussed(self: return 'I am focussed' _repr_=_repr_focussed # the default and then you can set the option with sage: parentClass.options(_repr_='fuzzy') This will set _repr_ = _repr__fuzzy --- or raise a ValueError if this is not a valid option. As a test case, I have implemented a prototype for partitions, however, the code is completely general. Just as importantly, it seems to work quite well. For those who want to see the details I will upload a patch trac_13605?--generic_partition_options-am.patch to the queue shortly. Here are some examples of how it works: sage: mu=Partition([4,4,3,2,1,1,1]); mu [4, 4, 3, 2, 1, 1, 1] sage: Partitions(4).options('_repr_') # the default behaviour is to print partitions as lists list Because of the underscores, using _repr_ as the option name seems slightly "wrong", so I allow an alias which in this case is 'display': sage: Partitions(4).options('display') list sage: Partitions(4).options(display='exp'); mu 1^3, 2, 3, 4^2 sage: mu._repr__exp() # this is what _repr_ now calls 1^3, 2, 3, 4^2 sage: Partitions(4).options(display='exp_high'); mu 4^2, 3, 2, 1^3 sage: Partitions(4).options(display='compact'); mu 1^3,2,3,4^2 sage: Partitions(4).options(display='compact_high'); mu 4^2,3,2,1^3 sage: Partitions(4).options(display='diagram'); sage: Partitions(4).options(convention='french'); mu * * * ** *** **** **** **** **** sage: Partitions(4).options(convention='english'); mu **** **** *** ** * * * sage: Partitions(4).options(cmp='dominance') sage: Partition([3,1,1,1])>Partition([2,2,2]) False sage: Partitions(4).options(cmp='lex') # lexicographic ordering sage: Partition([3,1,1,1])>Partition([2,2,2]) True sage: Partitions(4).options(display='exp'); mu 1^3, 2, 3, 4^2 sage: Partitions(4).options(display='exp_high'); mu 4^2, 3, 2, 1^3 sage: Partitions(4).options(display='list'); mu [4, 4, 3, 2, 1, 1, 1] sage: Partitions(4).options(display='exp_low') Traceback (most recent call last): ... ValueError: exp_low is not a valid option for display Above 'cmp' is an alias which controls the options of the four methods '__lt__', '__le__', '__ge__' and '__gt__'. So aliases allow options to be given sensible names and, in addition, they allow one option to change more than one method. With this scheme I am able to do everything which Travis does except (possibly?) for passing arguments to methods. (Travis allows you to globally set the character printed in a Ferrers diagram.) In the examples above I use Partitions(4) only because I added the options method to Partitions_n, rather than to Partitions_all, and these two classes are completely independent of each other because partitions are not fully integrated into the parent/element framework. Please let me know what you think. Cheers, Andrew ---- To save you looking at the patch here is the options method # the keys of option_alias are aliases to options, or groups of options. option_alias = {'cmp':['__le__','__lt__','__ge__','__gt__'], 'convention':['ferrers_diagram','_latex__diagram'], 'display':['_repr_'], 'latex':['_latex_'] } def options(self, *option, **options): r""" Print and set options for the element class of ``self``. Global options for the method ``foo`` of the element_class are methods with names of the form ``foo_<option name>``. For example, for :class:`Partition_class` the following optional methods for ``_repr_`` are currently implemented:: -_repr__list(self): -_repr__exp(self): -_repr__exp_high(self): -_repr__compact(self): -_repr__compact_high(self): -_repr__diagram(self): The global options can changed, and the current options printed, using ``self.options``: EXAMPLES:: sage: mu=Partition([4,4,3,2,1,1,1]); mu [4, 4, 3, 2, 1, 1, 1] sage: Partitions(4).options('_repr_') list sage: Partitions(4).options(_repr_='exp'); mu 1^3, 2, 3, 4^2 sage: Partitions(4).options(_repr_='exp_high'); mu 4^2, 3, 2, 1^3 sage: Partitions(4).options(_repr_='compact'); mu 1^3,2,3,4^2 sage: Partitions(4).options(_repr_='compact_high'); mu 4^2,3,2,1^3 sage: Partitions(4).options(_repr_='diagram'); sage: Partitions(4).options(convention='french'); mu * * * ** *** **** **** **** **** sage: Partitions(4).options(convention='endlish'); mu **** **** *** ** * * * sage: Partitions(4).options(cmp='dominance') sage: Partition([3,1,1,1])>Partition([2,2,2]) False sage: Partitions(4).options(cmp='lex') sage: Partition([3,1,1,1])>Partition([2,2,2]) True sage: Partitions(4).options(display='exp_low') Traceback (most recent call last): ... ValueError: exp_low is not a valid option for display The dictionary ``self.option_alias`` defines aliases for options so that the different options can be given more user friendly names. For example, ``display`` is an option for ``_repr__``:: EXAMPLES:: sage: Partitions(4).options(display='exp'); mu 1^3, 2, 3, 4^2 sage: Partitions(4).options(display='exp_high'); mu 4^2, 3, 2, 1^3 sage: Partitions(4).options(display='list'); mu [4, 4, 3, 2, 1, 1, 1] The values of ``self.option_alias`` are lists of strings so that one option can change several different methods. For example, the ``cmp`` option redefines the behaviour of the four comparison methods ``__le__``, ``__lt__``, ``__ge__`` and ``__gt__``. Note that we need need to append '__' to all method names which begin with '__' otherwise they are treated as inaccessible private methods. """ # todo: when called with no arguments a list of all options should be printed, # ...probably needs to be done via something like ``self.options_doc`` # -- # print the current settings for the options in ``option`` for opt in option: try: opt_name=self.option_alias.get(opt,[opt])[0] current_opt=getattr(self.element_class,opt_name).__name__ current_opt=current_opt[len(opt_name)+1:] if opt_name[:2]=='__': # some trickery to avoid private classes current_opt=current_opt[:-2] # remove trailing '__' print current_opt[len(opt_name):] except AttributeError: raise ValueError, '%s is not a valid option' % opt # change the option settings for the options in ``options`` for opt in options: for opt_name in self.option_alias.get(opt,[opt]): if opt_name[:2]=='__': # some trickery to avoid private classes new_opt=opt_name+'_'+options[opt]+'__' else: new_opt=opt_name+'_'+options[opt] if hasattr(self.element_class,new_opt): new_opt=getattr(self.element_class,new_opt) setattr(self.element_class, opt_name, new_opt) else: raise ValueError, '%s is not a valid option for %s' % (options[opt], opt) -- You received this message because you are subscribed to the Google Groups "sage-combinat-devel" group. To view this discussion on the web visit https://groups.google.com/d/msg/sage-combinat-devel/-/dyCBJ2ezC6cJ. To post to this group, send email to sage-combinat-devel@googlegroups.com. To unsubscribe from this group, send email to sage-combinat-devel+unsubscr...@googlegroups.com. For more options, visit this group at http://groups.google.com/group/sage-combinat-devel?hl=en.