Ask Your Question

Revision history [back]

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, for example we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
sage: t = 2

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, for example we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
sage: t = 2

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, for example we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
sage: t = 2

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, for example we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
sage: t = 2

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, for example as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
sage: t = 2

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
sage: ....: t = 2
....: # do something with t

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
....: t = 2
....: # do something with t

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t)exp(t) + sqrt(2)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
....: t = 2
....: # do something with t

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t) + sqrt(2)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol., whichs is very non-Pythonic.

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
....: t = 2
....: # do something with t

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t) + sqrt(2)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol, whichs is very non-Pythonic..

Here is a personal comment, there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
....: t = 2
....: # do something with t

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t) + sqrt(2)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

I would vote +1 if there were a SR.symbols doing the same wrapping as SR.var. Note that théy do not have the same semantics:

sage: a = SR.symbol('a,z')                                                                                                                                                                                   
sage: a                                                                                                                                                                                                      
a,z
sage: a + a                                                                                                                                                                                                  
2*a,z
sage: a = SR.var('a,z')                                                                                                                                                                                      
sage: a                                                                                                                                                                                                      
(a, z)
sage: a[0]^2                                                                                                                                                                                                 
a^2

Here is a personal comment, comment: there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
....: t = 2
....: # do something with t

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t) + sqrt(2)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

I would vote +1 if there were a SR.symbols doing the same wrapping as SR.var. Note that théy do not have the same semantics:

sage: a = SR.symbol('a,z')                                                                                                                                                                                   
sage: a                                                                                                                                                                                                      
a,z
sage: a + a                                                                                                                                                                                                  
2*a,z
sage: a = SR.var('a,z')                                                                                                                                                                                      
sage: a                                                                                                                                                                                                      
(a, z)
sage: a[0]^2                                                                                                                                                                                                 
a^2

Here is a personal comment: there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

sage: var("t")
....: t = 2
....: # do something with t

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t) + sqrt(2)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

I would vote +1 if there were a SR.symbols doing the same wrapping as SR.var. Note that théy SR.symbol and SR.var do not have the same semantics:

sage: a = SR.symbol('a,z')                                                                                                                                                                                   
sage: a                                                                                                                                                                                                      
a,z
sage: a + a                                                                                                                                                                                                  
2*a,z
sage: a = SR.var('a,z')                                                                                                                                                                                      
sage: a                                                                                                                                                                                                      
(a, z)
sage: a[0]^2                                                                                                                                                                                                 
a^2

Here is a personal comment: there is a real pedagogical benefit in using symbol instead of variable, as variable has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:things like:

sage: var("t")
....: t = 2
....: # do something with t

As if varwas used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

  • t is a Python name when we write t=2
  • t is a symbol when we write expr = exp(t) + sqrt(2)
  • t is an indeterminate when we write R.<t> = PolynomialRing(QQ)

Then, conistently, i tend to use SR.symbol instead of SR.var, not to mention the ugly var, which both creates a Python name and returns a symbol.

I would vote +1 if there were a SR.symbols doing the same wrapping as SR.var. Note that SR.symbol and SR.var do not have the same semantics:

sage: a = SR.symbol('a,z')                                                                                                                                                                                   
sage: a                                                                                                                                                                                                      
a,z
sage: a + a                                                                                                                                                                                                  
2*a,z
sage: a = SR.var('a,z')                                                                                                                                                                                      
sage: a                                                                                                                                                                                                      
(a, z)
sage: a[0]^2                                                                                                                                                                                                 
a^2
Copyright Sage, 2010. Some rights reserved under creative commons license. Content on this site is licensed under a Creative Commons Attribution Share Alike 3.0 license.
about | faq | help | privacy policy | terms of service
Powered by Askbot version 0.7.59