Comment #16 on issue 2260 by [email protected]: What should 0**0 return?
http://code.google.com/p/sympy/issues/detail?id=2260
Yes, I misunderstood what `.is_complex` means indeed.
[E] `x.is_complex` means that `x` is an element of the complex field.
[F] And since the ring of integers is included in the complex field (`ZZ`
in `CC`),
[G] `S.Zero.is_complex` is necessarily True.
First of all a negligible remark, may be arguable, but I just write a few
words now: integers *can be* included in the complex field.
And might be not included. (and if in the case of last, therefore `1/0 =
NaN` (integer singular) or `ioo`(integer), as what definition is better).
Also, integers can be included in other fields (or rings), and in a similar
above manner we deduce that `S.Zero.is_something==True` too.
But it confuse me if I see that something belongs simultaneously to two
fields especially when one of them is not embedded into other completely.
(I can't offhand give example to this field which not extension of
complex: Quaternionic field is just extension of complex numbers, and
split-complex numbers is not pure a field but only ring, I just notice that
`oo` and `zoo` can be treated as not pure field too).
Nevertheless this question is negligible (what is logic of simultaneously
belonging to the various different filed) .
But this question show itself worth if we consider a concept of rules: what
to do with values in symbolical algebra, (and every process there is a
finite automaton). When I handling with operation Add over a field and if
I encounter the complex on one hand and integer on the other, then quite
right I decide that integer can be treated as complex. Therefore I
implicitly apply your logic [F], [G].
But I apply it only in a place of operation `Add` and I have an implicit
rule how to extend : "if `x` is complex, and `y` is integer then I can
extend `y` to complex and produce Add further properly".
Then, if we consider operation `Div` with `S(1)` and `S(0)`, then this rule
does not work. Because I see: S.Zero is of course integer, and can be
extended to complex, but can be extended in other filed too, but the result
of various possibility will be different: as Nicolas noticed `roo` in
Reals, zoo in complex and so on.
So, what a conclusion I draw from it: behaviour of assumption [G] have
implicitly meaning of possibility to be complex indeed now.
And just that confuses us to the question of this issue.
About the global setting, yes I wanted a way to specify the field in which
operations take place.
And I afraid of global settings too.
But I just notice that, as it turned out, this global setting is
implicitly present now in SymPy too. But what is more. this setting is not
variable, but it is constant, and I can't even manage with it. In future it
will bring us to rigid box with CAS system, and in this rigid box now we
drive themselves. Instead of to use main benefit of SymPy as it based upon
the object oriented Python. In other words this issue must be well
thought-out, so I intend to estimate the current situation with a new
assumption module, and write concept about it too.
--
You received this message because you are subscribed to the Google Groups
"sympy-issues" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/sympy-issues?hl=en.
