Graph theory has already been ruled out for SymPy:
https://github.com/sympy/sympy/issues/8186
Most graph-theoretic algorithms are not symbolic and don't really have
any connection to the symbolic manipulation that SymPy does.
That being said there is plenty of scope to use graph theoretic
I should clarify that what I said is opinionated (my opinion in
particular!) so it's possible others disagree. Certainly there is a
lot of code in SymPy that doesn't follow the advice above.
If we want a cached_property decorator then we can add this somewhere
in sympy/utilities or perhaps
Great, that is exactly what I've been trying to find!
By the way, there is caching property decorator called `@cached_property`,
that does exactly what you suggested. It is, however, not in the standard
library (https://pypi.org/project/cached-property/). Maybe it would be
beneficial to add it to
In my opinion, SymPy is concerned about symbolic manipulation and
mathematics. The topics you suggested will be more appropriate for a data
structures and algorithms libraries. If other members agree on your
suggestion, then feel free to draft a issue for further discussion.
In addition, I see
All Right.
Topics such as Graph Theory( Creating Graph Data Structures, Standard Graph
Algorithms such as BFS and DFS, Graph Analysis, Centrality and even trivial
things such as checking if a degree sequence is a graphic or not, etc)
Topology (Network Topology : Creating and testing).
I am
All Right.
Topics such as Graph Theory( Creating Graph Data Structures, Standard Graph
Algorithms such as BFS and DFS, Graph Analysis and even trivial things such
as checking if a degree sequence is a graphic or not, etc) and Network
Topology (Creating and testing).
I am sorry for the delay
Preventing assignment isn't necessary for the internal workings of
SymPy. The only advantage it has is potentially avoiding confusion for
users. I don't particularly see users getting confused about this
though (although maybe that's because of the widespread use of
properties).
What I think is
There are several ways to implement properties of sympy objects. The
simplest one is:
```
def __new__(*args):
obj = Basic(*args)
obj.prop = 'some_property'
```
A slightly more complicated one is:
```
def __new__(*args):
obj = Basic(*args)
obj._prop = 'some_property'
@property
def
