Ticket #6559: trac_6559-domain-and-latex_name-for-variable.take2.3.patch

sage/calculus/var.pyx

@@ -10 +10 @@
     - ``s`` - a string, either a single variable name, or a space or
       comma separated list of variable names.
 
+    - ``kwds`` - keyword arguments can be given to specify domain and
+      custom latex_name for variables. See EXAMPLES for usage.
+
     .. note::
 
        The new variable is both returned and automatically injected
-       into the global namespace.  If you use var in library code, it
-       is better to use sage.symbolic.ring.var, since it won't
-       touch the global namespace.
+       into the global namespace. If you need symbolic variable in
+       library code, it is better to use either SR.var() or SR.new_var().
 
     EXAMPLES:
     
@@ -29 +31 @@
         sage: f = xx^n + yy^n + zz^n; f
         xx^n + yy^n + zz^n
 
+    By default, var returns complex variable. To define real or positive 
+    variable we can specify its domain as::
+
+        sage: x = var('x', domain=RR); x; x.conjugate()
+        x
+        x
+        sage: y = var('y', domain='real'); y.conjugate()
+        y
+        sage: y = var('y', domain='positive'); y.abs()
+        y
+
+    Custom latex expression can be assigned to variable::
+
+        sage: x = var('sui', latex_name="s_{u,i}"); x._latex_()
+        's_{u,i}'
+
+    In notebook, we can also colorize latex expression::
+
+        sage: x = var('sui', latex_name="\\color{red}{s_{u,i}}"); x._latex_()
+        '\\color{red}{s_{u,i}}'
+
     We can substitute a new variable name for n::
     
         sage: f(n = var('sigma'))
@@ -81 +104 @@
             deprecation("The new (Pynac) symbolics are now the only symbolics; please do not use keyword 'ns' any longer.")
         else:
             raise NotImplementedError, "The new (Pynac) symbolics are now the only symbolics; please do not use keyword `ns` any longer."
-    v = new_var(s)
+    v = new_var(s, **kwds)
     if isinstance(v, tuple):
         for x in v:
             G[repr(x)] = x

sage/libs/ginac/decl.pxi

@@ -25 +25 @@
 
 
     ctypedef struct GSymbol "symbol":
-        pass
-
+        unsigned get_domain()
+        void set_domain(unsigned d)
+        void set_texname(char* t)
+ 
     GSymbol* GSymbol_construct_str "Construct_p<symbol, char*>" \
             (void *mem, char* m)
 
@@ -208 +210 @@
     GEx g_pow "pow" (GEx left, GEx exp)      except +
 
     GSymbol get_symbol(char* s)              except +
+    GSymbol ginac_symbol "GiNaC::symbol" (char* s, char* t, unsigned d) except +
+    GSymbol ginac_new_symbol "GiNaC::symbol" () except +
     GEx g_collect_common_factors "collect_common_factors" (GEx e) except +
 
     # standard library string

sage/symbolic/ring.pyx

@@ -31 +31 @@
 from sage.structure.parent_base import ParentWithBase
 from sage.rings.ring cimport CommutativeRing
 from sage.categories.morphism cimport Morphism
+            
+pynac_symbol_registry = {}
 
 cdef class SymbolicRing(CommutativeRing):
     """
@@ -412 +414 @@
         from sage.symbolic.constants import pi
         return self(pi)
 
-    cpdef symbol(self, name):
+    cpdef symbol(self, name=None, latex_name=None, domain=None):
         """
         EXAMPLES::
 
-            sage: SR.symbol("asdfasdfasdf")
-            asdfasdfasdf
+            sage: tmp0_var = SR.symbol("tmp0_var")
+            sage: tmp0_var.conjugate()
+            conjugate(tmp0_var)
+
+            sage: tmp0_var = SR.symbol("tmp0_var", domain='real')
+            sage: tmp0_var.conjugate()
+            tmp0_var
+
+            sage: tmp0_var.abs()
+            abs(tmp0_var)
+
+            sage: tmp0_var = SR.symbol("tmp0_var", domain='positive')
+            sage: tmp0_var.abs()
+            tmp0_var
+
+            sage: tmp0_var = SR.symbol(); tmp0_var  #random
+            symbol343
         """
-        cdef GSymbol symb = get_symbol(name)
+        # Decide the domain
+        from sage.rings.all import RR
+        if domain is 'real' or domain is RR:
+            domain = domain_real
+        elif domain is 'positive':
+            domain = domain_positive
+        else:
+            domain = domain_complex
+        cdef GSymbol symb
         cdef Expression e
-        e = <Expression>PY_NEW(Expression)
-        GEx_construct_symbol(&e._gobj, symb)
-        e._parent = SR
+        # Check if there is already a symbol of same name
+        try:
+            e = pynac_symbol_registry[name]
+            symb = ex_to_symbol((<Expression>e)._gobj)
+            if symb.get_domain() is domain and latex_name is None:
+                return e
+            else:
+                if not symb.get_domain() is domain:
+                    symb.set_domain(domain)
+                if latex_name is not None:
+                    symb.set_texname(latex_name)
+                GEx_construct_symbol(&e._gobj, symb)
+        except KeyError:
+            # Check if we need a distinct new symbol
+            if name is None:
+                symb = ginac_new_symbol()
+                if not domain is domain_complex:
+                    symb.set_domain(domain)
+            else:
+                # Get a ginac symbol with given name
+                name = str(name)
+                if latex_name is None:
+                    from sage.misc.latex import latex_variable_name
+                    latex_name = latex_variable_name(name)
+                symb = ginac_symbol(name, latex_name, domain)
+            # Construct expression
+            e = <Expression>PY_NEW(Expression)
+            GEx_construct_symbol(&e._gobj, symb)
+            e._parent = SR
+            pynac_symbol_registry[repr(e)] = e
         return e
 
-    def var(self, name):
+    def var(self, name, **kwds):
         """
         Return the symbolic variable defined by x as an element of the
         symbolic ring.
@@ -445 +497 @@
         if not isinstance(name, str):
             name = repr(name)
         if ',' in name:
-            return tuple([self.symbol(s.strip()) for s in name.split(',')])
+            return tuple([self.symbol(s.strip(), **kwds) for s in name.split(',')])
         elif ' ' in name:
-            return tuple([self.symbol(s.strip()) for s in name.split(' ')])
+            return tuple([self.symbol(s.strip(), **kwds) for s in name.split(' ')])
         else:
-            return self.symbol(name)
+            return self.symbol(name, **kwds)
+
+    def new_var(self, domain=None):
+        """
+        Returns a unique symbolic variable as an element of the symbolic ring.
+        This is useful for situation where a temporary but distinct variable
+        (apart from those already in use) is needed.
+        
+        EXAMPLES::
+        
+            sage: tmpvar = SR.new_var(); tmpvar  #random
+            symbol343
+            sage: tmpvar = SR.new_var(domain='real'); tmpvar  #random
+            symbol347
+        """
+        return self.symbol(name=None, domain=domain)
 
     def _repr_element_(self, Expression x):
         """
@@ -667 +734 @@
     """
     return R is SR
 
-def var(name):
+def var(name, **kwds):
     """
     EXAMPLES::
     
@@ -681 +748 @@
         sage: var("z")
         z
     """
-    return SR.var(name)
+    return SR.var(name, **kwds)
 
 def is_SymbolicVariable(x):
     """