Mathics is a general-purpose computer algebra system (CAS). It is an open-source alternative to Mathematica

Overview

Welcome to Mathics!

Pypi Installs Latest Version Supported Python Versions SlackStatus

Packaging status

Mathics is a general-purpose computer algebra system (CAS). It is an open-source alternative to Mathematica. It is free both as in "free beer" and as in "freedom".

The home page of Mathics is https://mathics.org.

ScreenShots

mathicsscript: a text interface

mathicsscript

mathicsserver: a Django-based Web interface

mathicssserver

Installing and Running

See the read the docs guide for instructions on installing and running.

Contributing

Please feel encouraged to contribute to Mathics! Create your own fork, make the desired changes, commit, and make a pull request.

License

Mathics is released under the GNU General Public License Version 3 (GPL3).

Comments
  • Double Integration is very slow, while almost instant in maxima.

    Double Integration is very slow, while almost instant in maxima.

    Integrate[Integrate[20000*E^y/(1-x/2),{x,-5,0}],{y,-3,0}]+Integrate[Integrate [20000*E^y/(1+x/2),{x,0,5}],{y,-3,0}] is much slower in Mathics than maxima.

    opened by DUOLabs333 52
  • Use ASCII to Unicode tables for Infix operators

    Use ASCII to Unicode tables for Infix operators

    ./admin-tools/make-op-tables.sh builds the JSON tables.

    Also, environment variable MATHICS_CHARACTER_ENCODING can be used to set $SystemCharacterEncoding and the initial value of $CharcterEncoding.

    Some adjustments to tests with DifferentialD were made so we use standard Unicode symbols not WMA unicode.

    There was a bug in gstest from a prior commit in mathics-scanner where the "pre-scanner()" was replacing strings starting with "|".


    I had a hard time understanding the flow of what's going on, and this process was both painful and made me a bit annoyed.

    I was pleased though at @mmatera start to move the makeboxes into its own module, and we have a little bit of segregating boxing routines, so that I suppose helps a little.

    It is not that the code isn't sophisticated or complicated. It is just that it is not organized and changes haven't been coordinated.

    Let me describe a little of the history around this PR and the code I see, and reflect. The aim show of this reflection shows how the code has become of poorer quality, is in constant need of serious refactoring, and can get worse with uncoordinated bug fixes or feature improvements. Functionally the code does a quite a bit; but it is at the cost of lots of code with undue complexity. I assume that much of the complicated code is to ensure correct behavior.

    However, where we find that the code is not correct or lacking, we have a hard time figuring out where to go and what to change that isn't going to impact a lot of other things.

    mmatera notes a problem with infix operator behavior in the ascii-op-to-Unicode branch. I had sort of seen this when I wrote that branch initially. One thing that I noticed that was was wrong in my PR is that the place where the change occurs felt wrong: it is code inside a "MakeBox" rule. But this rule is defined on class creation or registering each of the infix operators. These rules are is never changed. Something like $CharacterEncoding can change at will, so this location is too static.

    Therefore I had to give up (temporarily) on making this work for $CharacterEncoding. Instead, I used the less dynamic $SystemCharacterEncoding instead.

    Looking over this in a second pass, I see now that a rule like this is boneheaded:

    formatted_output = 'MakeBoxes[Infix[{%s}," %s ",%d,%s], form]' % ( replace_items, operator, self.precedence, self.grouping, ) default_rules = {

    ...

    "MakeBoxes[{0}, form:InputForm|OutputForm]".format(op_pattern): formatted_output } Do you see why? ...

    Hint: it is in the " %s " part.

    This is supposed to be a rule that is called when boxing infix operators. And already it is deciding that operators should be surrounded by spaces for "InputForm" and "OutputForm". In other words, right here in part which dictates rules to Box Infix expressions, we are already making decisions about the low-level formatting: that there should be spaces around the operator and what characters to use to represent the operator.

    And when we actually get to the low-level format to final string, we have lost structure. Basically we have violated the principle that you evaluate to get an M-expression, then you Box the result, and then after Boxing then a low-level formatting is done.

    If we want to write dozens more forms, the above isn't scalable. And we make high-quality formatting harder.

    At some level this was probably noticed, at least implicitly; when there are such few comments it is hard to know what was noticed and what was just random programming by reacting to problems that come up. Since everything can't be done by MakeBox rules, we have do_format_xxx routines in mathics-core/mathics/core/formatter.py as well as special routines in builtin/arithfns/basic.py, builtin/pympler/asizeof.py, some that are done on inside MakeBox() internal functions.

    In short, since principles if they were decided or defined, they were not communicated anywhere I can tell; so naturally formatting codes is scattering at many of places in the code at several conceptual levels. Possibly some of the code is redundant or worse, works cross purposes.

    If discussion of high-level principle were lacking, so are basic description code. Things like docstrings on functions. Or making an effort to name what a function does. For example take the get_op() an interanal function inside evaluation method apply_infix() leaving aside the missing apply_ prefix that I have mentioned many times before.

    What is get_op() "getting"? You already pass it some sort of operator. If you look at the function you realize it is not getting or accessing something, but rather converiting or formatting.

    And then once you realize that you are then in a position to ask why is this routine formatting inside a Boxing routine? In the overall architecture isn't a separate step. Or should low-level formatting routines, be put together?

    Vagueness in code, lack of description and discussion around the code has led to very haphazard code that, in the end result, does not seem fully thought out.

    With all the effort spent in just figuring out what he code does; by the time I understand that, I am exhausted and often not in a mood to think about how it should be designed or whether it follows a design or how to best write this.

    Let me come back to adding spaces around the operator and losing the operator structure (the " %s " part) one more time. Because of this, the "remedy" was put in place that makes things worse. A routine was added that scans strings and unconditionally changes some strings (e.g. ASCII-formatted operators) into Unicode characters. I doesn't matter if this was done by ignorance, willful frustration: in the end, it makes the code a bigger mess.

    It is, as I say, like trying to solve a Rubik's cube by getting adjacent faces in line one at a time. In the beginning there is a certain satisfaction because you can "make progress". However getting to the end this way is much harder than understanding what is going on performing operations that work in conjunction with the principles and groups of the Rubik's cube.

    Given all this, my inclination right now is to hold off on adding new Forms, or correcting the existing ones to be more correct. Instead if we just make things work they do but in a logical sensible and extensible way, I think this would buy us the most to then correct the existing behavior to match the specifications more closely and to add more Forms.

    opened by rocky 34
  • allowing singletonize Symbols

    allowing singletonize Symbols

    @rocky, maybe you can help me with this. For some reason, all the test pass if I enable the line that singletonizes the Symbol class, except for one test in combinatorica. As you know better that code, could you help me investigating why this happens?

    If this starts to work, I guess that we can get an improvement in performance if we use the id() of the symbols instead of the string name the symbol in the pattern matching routines.

    opened by mmatera 34
  • Add builtin Diagonal

    Add builtin Diagonal

    I tried to implement Diagonal and it seems working. In https://github.com/Mathics3/mathics-core/issues/115 is proposed to use native Wolfram Language, but I hope this it will be sufficient, at least for the moment.

    opened by adamantinum 27
  • Reduce unnecessary expansion & untangle imports...

    Reduce unnecessary expansion & untangle imports...

    A number of different kinds of atoms that can't change value unnecessarily go through an extra expansion for fixpoint check.

    In particular many constants values: strings, numbers, fixed symbols e.g. True, False, N, etc.

    The one place where we do need to check though is Symbol, because a value like "x" may change. So we separate Symbols from Constants.

    Also we remove "import" of a name where that name isn't used directly in the module. This seems to happen so that some other module can find the name instead of where it was defined. This isn't helpful. In fact, it is the opposite.

    opened by rocky 24
  • Invalid syntax  result from Integrate command.

    Invalid syntax result from Integrate command.

    Using 4.0 on Linux, I get the following

    mathics

    Mathics 4.0.0
    on CPython 3.10.4 (main, Apr  2 2022, 09:04:19) [GCC 11.2.0]
    using SymPy 1.10.1, mpmath 1.2.1, numpy 1.22.4
    
    Copyright (C) 2011-2021 The Mathics Team.
    This program comes with ABSOLUTELY NO WARRANTY.
    This is free software, and you are welcome to redistribute it
    under certain conditions.
    See the documentation for the full license.
    
    Quit by evaluating Quit[] or by pressing CONTROL-D.
    
    In[1]:= Integrate[(1 - x^3)^(2/3)/x,x]
    Out[1]= --1 ^ (2 / 3) x ^ 2 Gamma[-2 / 3] hyper[{-2 / 3, -2 / 3}, {1 / 3}, 1 / x ^ 3] / (3 Gamma[1 / 3])
    
    

    Notice the --1 output. This is an error. Mathematica says

    PreDecrement::rvalue: 1 is not a variable with a value, so its value cannot be changed.

    Btw, as a side issue, what is hyper[ function above? There is no such function in Mathematica.

    But the main problem is generating --1

    opened by nasser1 20
  • Double integration with `f(x,y)=1` fails, while any other constant succeeds

    Double integration with `f(x,y)=1` fails, while any other constant succeeds

    Integrate[Integrate[1,{y,0,E^x}],{x,0,Log[13]}] gives Integrate[ConditionalExpression[E, {True}], {x, 0, Log[13]}] when Integrate[Integrate[2,{y,0,E^x}],{x,0,Log[13]}] or Integrate[Integrate[0,{y,0,E^x}],{x,0,Log[13]}] or even Integrate[Integrate[0.9999999,{y,0,E^x}],{x,0,Log[13]}] works.

    opened by DUOLabs333 17
  • Try Specializing the Abs[] function

    Try Specializing the Abs[] function

    We get perhaps a 10%-20% improvement:

    In[1]:= Timing[AbsFast[I + 3]]
    Out[1]= {0.00704927, Sqrt[10]}
    
    In[2]:= Timing[AbsFast[I + 3]]
    Out[2]= {0.00116204, Sqrt[10]}
    
    In[3]:= Timing[Abs[I + 3]]
    Out[3]= {0.00120341, Sqrt[10]}
    
    In[4]:= Timing[Abs[I]]
    Out[4]= {0.00029366, 1}
    
    In[5]:= Timing[Abs[I]]
    Out[5]= {0.00030883, 1}
    
    In[6]:= Timing[AbsFast[I]]
    Out[6]= {0.000244551, 1}
    

    Note that due to caching, in comparisons, we should run an expression twice and use the second (cached) value.

    Specific specialization:

    We can fold in knowledge of the specific sympy and mpmath functions (Abs and fabs) that get called rather than having to look them up.

    Because there is exactly one argument, we don't need argument looping mechanisms.

    In general, things like this.

    opened by rocky 13
  • using ``installed`` property to skip tests

    using ``installed`` property to skip tests

    This PR is a previous step for adding a Pyston test workflow (see #368). The proposed changes allow skipping the tests associated with symbols whose evaluation requires not available external libraries.

    To check that indeed this works with a minimal environment, I added here a workflow to check that in standard Ubuntu Python.

    opened by mmatera 12
  • List as atom

    List as atom

    In this PR, a basic proposal about how to handle List evaluations is implemented. Same ideas could be implemented to other frequently used symbols, or certain direct sympy expressions.

    opened by mmatera 12
  • Singletonize

    Singletonize

    Here is the next step in the road to use Symbols as a singleton class. With this #PR, in my machine, I could reduce in 30s the 4min 30s ' docpipeline runtime.

    Most of the evaluation process involves to compare Symbols, look for definitions and reformat Expressions accordingly. Until now, each time we rebuild an expression object, we had to recreate Symbols by their names. This triggered class constructors and string formatting checking. On the other hand, each time that a Symbol was compared against another expression, we had to look at its name and make str comparisons. With the new implementation, a big part to that overhead is eliminated. The next step would be to reformulate in the same way has_form, and finally, the Definitions object.

    opened by mmatera 12
  • reimplementing eval_makeboxes. step 1

    reimplementing eval_makeboxes. step 1

    This is the first step in my proposal of refactoring MakeBoxes. The main change here is that MakeBoxes rules are applied in mathics.eval.makeboxes.eval_makeboxes instead of the mathics.core.expression.rewrite_apply_eval_step. In a next step, makeboxes rules are going to be stored not as downvalues of the MakeBoxes symbol, but as format values.

    opened by mmatera 1
  • Issues to address before 6.0.0 release

    Issues to address before 6.0.0 release

    • [x] Import["ExampleData/MadTeaParty.gif"] is broken
    • [x] Show SciPy version (or non) under version info (and in Django)
    • [x] (Django) Go over gallery examples, possibly add new stuff. color boxes are too small
    • [ ] Asymptote axes for Plot are misaligned possibly now that they are aligned for SVG
    • [ ] LaTeX doc rendering of Asymptote graphs is misaligned. Go over LaTeX doc for content
    • [x] Remove Combinatorica error in trying to redefine CatalanNumber
    • [ ] Go over text in docs for links and text.
    • [ ] Replace all methods named apply which are really eval methods? And remove acceptance of apply in the contribute() function?
    • [ ] Go over CHANGES.rst (which is really part of the release itself.
    opened by rocky 3
  • Integrate Mathics-native 'MakeBoxes' layout into TeXmacs as a plugin.

    Integrate Mathics-native 'MakeBoxes' layout into TeXmacs as a plugin.

    I would like to be able to load a Mathics notebook into TeXmacs and work with it in the native MakeBoxes format of Wolfram language notebooks instead of being forced to convert it to HTML/CSS or LaTeX first.

    Will also post this request on TeXmacs mailing list as an idea for a new plugin.

    opened by gtusr 2
  • PyPy 3.9 not supported

    PyPy 3.9 not supported

    Description

    1. Attempting to install Mathics-omnibus gets stuck at Installing build dependencies ... |.
    2. Attempting to install Mathics3 raises the following error:
    gcc -pthread -DNDEBUG -O2 -fPIC -I/home/hyperswine/.pyenv/versions/pypy3.9-7.3.10/include/pypy3.9 -c lib/recordclass/_litelist.c -o build/temp.linux-x86_64-3.9/lib/recordclass/_litelist.o
    lib/recordclass/_litelist.c: In function ‘litelist_resize’:
    lib/recordclass/_litelist.c:31:56: error: ‘PyLiteListObject’ {aka ‘PyListObject’} has no member named ‘ob_item
    

    How to Reproduce

    1. From a popos (ubuntu 22.04) environment with pypy 3.9.15, run pip install Mathics-omnibus. And get the error in 1
    2. From the same environment, run pip install Mathics3. And get the error in 2

    Expected behavior

    Not get stuck at installing build dependencies and not raise an error. I did check the recordclass source code, and it seems like the PyLiteListObject struct did not in fact contain ob_item. Unless Im seeing things, that does seem like a problem with that dependency, so I actually don't know why Mathics3 works when its including that dep.

    Your Environment

    • PopOS 22.04, Intel + Nvidia
    • Pypy 3.9.15 through pyenv
    • No other mathematica /mathics installs on the system
    opened by hyperswine 1
  • Move `mathics.core.builtin` initialization code into `system_initialize()`

    Move `mathics.core.builtin` initialization code into `system_initialize()`

    @mmatera and @TiagoCavalcante : this is kind of important to understand.

    Although we now require a frontend to explicitly call initialize_system() and this may seem more awkward, it is helpful and important for a couple of reasons.

    First: it provides better modularization and reduces circular imports.

    mathics.builtin is close to top-level import and, in contrast to mathics.core.system_init there are a lot of modules underneath mathics.builtin. (There are none under mathics.core.system_init).

    In general, it is considered bad Python coding practice to put a lot of code in __init__.py files.

    As a result, we can have more import mathics.core.system_init from a module where we can't do the same for import mathics.builtin.

    Second: by placing initialization of structures which do not change outside of development we are in a better position to write an administrative tool to load all of this and then dump it as a system image file, which can be read in rather than built it up from scratch as happens now. This new function initialize_system might have a parameter to read the image file rather than do the work it does now.

    In its current form though initialize_system() does as not encapsulate system loading as much as it could.

    opened by rocky 5
Releases(5.0.2)
  • 5.0.1(Aug 6, 2022)

    Overview

    Mostly a release to fix a Python packaging problem.

    • format and do_format methods were removed from the interface of BaseElement, becoming non-member functions.
    • The class BoxElement was introduced as a base for boxing elements.

    New Builtin

    • 'Inverse Gudermannian'.

    Documentation

    Hyperbolic functions were split off form trigonometry and exponential functions. More url links were added.

    Bugs

    *r Creating a complex number from Infinity no longer crashes and returns 'I * Infinity'

    Source code(tar.gz)
    Source code(zip)
    Mathics3-5.0.1-py3-none-any.whl(2.61 MB)
    Mathics3-5.0.1-py3.10.egg(3.65 MB)
    Mathics3-5.0.1-py3.6.egg(3.63 MB)
    Mathics3-5.0.1-py3.7.egg(3.63 MB)
    Mathics3-5.0.1-py3.8.egg(3.64 MB)
    Mathics3-5.0.1-py3.9.egg(3.63 MB)
    Mathics3-5.0.1.tar.gz(2.75 MB)
  • 5.0.0(Jul 31, 2022)

    Table of Contents

    This release starts to address some of the performance problems and terminology confusion that goes back to the very beginning. As a result, this release is not API compatible with prior releases.

    In conjunction with the performance improvement in this release, we start refactoring some of the core classes and modules to start to get this to look and act more like other interpreters, and to follow more current Python practice.

    More work will continue in subsequent releases.

    New Builtins

    1. Euler's Beta function.
    2. Bernoulli.
    3. CatalanNumber (Integer arguments only).
    4. CompositeQ.
    5. Diagonal. Issue #115.
    6. Divisible.
    7. EllipticE
    8. EllipticF
    9. EllipticK
    10. EllipticPi
    11. EulerPhi
    12. $Echo. Issue #42.
    13. FindRoot was improved for supporting numerical derivatives Issue #67, as well as the use of scipy libraries when are available.
    14. FindRoot (for the newton method) partially supports EvaluationMonitor and StepMonitor options.
    15. FindMinimum and FindMaximum now have a minimal implementation for 1D problems and the use of scipy libraries when are available.
    16. LogGamma.
    17. ModularInverse.
    18. NumericFunction.
    19. Projection.
    20. Partial support for Graphics option Opacity.
    21. SeriesData operations was improved.
    22. TraceEvaluation[] shows expression name calls and return values of it argument.
      • Pass option ShowTimeBySteps, to show accumulated time before each step
      • The variable $TraceEvalution when set True will show all expression evaluations.
    23. TraditionalForm

    Enhancements

    1. D acts over Integrate and NIntegrate. Issue #130.
    2. SameQ (===) handles chaining, e.g. a == b == c or SameQ[a, b, c].
    3. Simplify handles expressions of the form Simplify[0^a] Issue #167.
    4. Simplify and FullSimplify support optional parameters Assumptions and ComplexityFunction.
    5. UnsameQ (=!=) handles chaining, e.g. a =!= b =!= c or UnsameQ[a, b, c].
    6. Assignments to usage messages associated with Symbols is allowed as it is in WMA. With this and other changes, Combinatorica 2.0 works as written.
    7. Share[] performs an explicit call to the Python garbage collection and returns the amount of memory free.
    8. Improve the compatibility of TeXForm and MathMLForm outputs with WMA. MathML tags around numbers appear as "<mn>" tags instead of "<mtext>", except in the case of InputForm expressions. In TeXForm some quotes around strings have been removed to conform to WMA. It is not clear whether this is the correct behavior.
    9. Allow scipy and skimage to be optional. In particular: revise Nintegrate[] to use Method="Internal" when scipy isn't available.
    10. Pyston up to versions from 2.2 to 2.3.4 are supported as are PyPy versions from 3.7-7.3.9.0 up 3.9-7.3.9. However those Python interpreters may have limitations and limitations on packages that they support.
    11. Improved support for Series Issue #46.
    12. Cylinder rendering is implemented in Asymptote.

    Documentation

    1. "Testing Expressions" section added.
    2. "Representation of Numbers" section added.
    3. "Descriptive Statistics" section added and "Moments" folded into that.
    4. Many More URL references. <url> now supports link text.
    5. Referecne Chapter and Sections are now in alphabetical order
    6. Two-column mode was removed in most sections so the printed PDF looks nicer.
    7. Printed Error message output in test examples is in typewriter font and doesn't drop inter-word spaces.

    Internals

    1. Inexplicably, what the rest of the world calls a "nodes" in a tree or or in WMA "elements" in a tree had been called a "leaves". We now use the proper term "element".
    2. Lots of predefined Symbols have been added. Many appear in the module mathics.core.systemsymbols.
    3. Attributes are now stored in a bitset instead of a tuple of string. This speeds up attributes read, and RAM usage, .
    4. Symbol.is_numeric and Expression.is_numeric now uses the attribute Definition.is_numeric to determine the returned value.
    5. NIntegrate internal algorithms and interfaces to scipy were moved to mathics.algorithm.integrators and mathics.builtin.scipy_utils.integrators respectively.
    6. N[Integrate[...]] now is evaluated as NIntegrate[...]
    7. Definitions for symbols CurrentContext and ContextPath[] are mirrored in the mathics.core.definitions.Definitions object for faster access.
    8. FullForm[List[...]] is shown as {...} according to the WL standard.
    9. Expression.is_numeric() accepts an Evaluation object as a parameter; the definitions attribute of that is used.
    10. SameQ first checks the type, then the id, and then names in symbols.
    11. In mathics.builtin.patterns.PatternTest, if the condition is one of the most used tests (NumberQ, NumericQ, StringQ, etc) the match method is overwritten to specialized versions that avoid function calls.
    12. mathics.core.patterns.AtomPattern specializes the comparison depending of the Atom type.
    13. To speed up development, you can set NO_CYTHON to skip Cythonizing Python modules. If you are using Pyston or PyPy, Cythonization slows things down.
    14. any andall calls were unrolled as loops in Cythonized modules: this avoids the overhead of a function call replacing it by a (C) for loop, which is faster.
    15. A bug was fixed relating to the order in which mathics.core.definitions stores the rules
    16. InstanceableBuiltin -> BuiltinElement
    17. BoxConstruction -> BoxExpression
    18. the method Element.is_true() was removed in favor of is SymbolTrue
    19. N[_,_,Method->method] was reworked. Issue #137.
    20. The methods boxes_to_* were moved to BoxExpression.
    21. remove flatten_* from the Atom interface.
    22. Definition has a new property is_numeric.

    Speed improvements:

    1. Creating two Symbol objects with the same name will give the same object. This avoids unnecessary string comparisons, and calls to ensure_context.
    2. Attributes are now stored in a bitset instead of a tuple of strings.
    3. The Definitions object has two properties: current_contex and context_path. This speeds up the lookup of symbols names. These properties store their values into the corresponding symbols in the builtin definitions.
    4. eval_N was add to speed up the then often-used built-in function N.
    5. Expression evaluation was gone over and improved. properties on the collection which can speed up evaluation, such as whether an expression is fully evaluated, is ordered, or is flat are collected.
    6. List evaluation is customized. There is a new ListExpression class which has a more streamlined evaluate() method. More of this kind of thing will follow
    7. BaseExpression.get_head avoids building a symbol saving two function calls.

    Package update

    1. SymPy 1.10.1

    Compatibility

    1. ScriptCommandLine now returns, as the first element, the name of the script file (when available), for compatibility with WMA. Issue #132.

    2. Expression.numerify improved in a way to obtain a behavior closer to WMA.

    3. NumericQ lhs expressions are now handled as a special case in assignment. For example NumericQ[a]=True tells the interpreter that a must be considered

    4. a numeric quantity, so NumericQ[Sin[a]] evaluates to True.

    Bugs

    1. First, Rest and Last now handle invalid arguments.
    2. Set*: fixed issue #128.
    3. SameQ: comparison with MachinePrecision only needs to be exact within the last bit Issue #148.
    4. Fix a bug in Simplify that produced expressions of the form ConditionalExpression[_,{True}].
    5. Fix bug in Clear and ClearAll (#194).
    6. Fix base 10 formatting for infix Times. Issue #266.
    7. Partial fix of FillSimplify
    8. Streams used in MathicsOpen are now freed and their file descriptors now released. Issue #326.
    9. Some temporary files that were created are now removed from the filesystem. Issue #309.
    10. There were a number of small changes/fixes involving NIntegrate and its Method options. Nintegrate tests have been expanded.
    11. Fix a bug in handling arguments of pythonized expressions, that are produced by Compile when the llvmlite compiler fails.
    12. N now handles arbitrary precision numbers when the number of digits is not specified.
    13. [N[Indeterminate]]{.title-ref} now produces [Indeterminate]{.title-ref} instead a [PrecisionReal(nan)]{.title-ref}.
    14. Fix crash in NestWhile when supplying All as the fourth argument.
    15. Fix the comparison between Image and other expressions.
    16. Fix an issue that prevented that [Collect]{.title-ref} handles properly polynomials on expressions (issue #285).
    17. Fix a bug in formatting expressions of the form (-1)^a without the parenthesis (issue #332).
    18. Fix a but in failure in the order in which mathics.core.definitions stores the rules.
    19. Numeric overflows now do not affect the full evaluation, but instead just the element which produce it.
    20. Compatibility with the way expressions are ordered more closely follows WMA: Now expressions with fewer elements come first (issue #458).
    21. The order of the context name resolution (and $ContextPath) was switched; "System comes before "Global.

    Incompatible changes

    The following changes were motivated by a need to speed up the interpreter.

    1. Expression arguments differ. The first parameter has to be a Symbol while the remaining arguments have to be some sort of BaseElement rather than something that can be convertedr to an element.

    2 Properties for the collection of elements can be specified when they are known. To get the old behavior, use to_expression

    1. Expressions which are lists are a new kind of class, ListExpression. As with expressions, the constructor requires valid elements, not something convertible to an element. Use to_mathics_list
    Source code(tar.gz)
    Source code(zip)
    Mathics3-5.0.0-py3-none-any.whl(2.60 MB)
    Mathics3-5.0.0-py3.10.egg(3.63 MB)
    Mathics3-5.0.0-py3.6.egg(3.61 MB)
    Mathics3-5.0.0-py3.7.egg(3.61 MB)
    Mathics3-5.0.0-py3.8.egg(3.62 MB)
    Mathics3-5.0.0-py3.9.egg(3.62 MB)
    Mathics3-5.0.0.tar.gz(2.74 MB)
Datamol is a python library to work with molecules

Datamol is a python library to work with molecules. It's a layer built on top of RDKit and aims to be as light as possible.

datamol 276 Dec 19, 2022
Zipline, a Pythonic Algorithmic Trading Library

Zipline is a Pythonic algorithmic trading library. It is an event-driven system for backtesting. Zipline is currently used in production as the backte

Quantopian, Inc. 15.7k Jan 07, 2023
ReproZip is a tool that simplifies the process of creating reproducible experiments from command-line executions, a frequently-used common denominator in computational science.

ReproZip ReproZip is a tool aimed at simplifying the process of creating reproducible experiments from command-line executions, a frequently-used comm

267 Jan 01, 2023
Algorithms covered in the Bioinformatics Course part of the Cambridge Computer Science Tripos

Bioinformatics This is a repository of all the algorithms covered in the Bioinformatics Course part of the Cambridge Computer Science Tripos Algorithm

16 Jun 30, 2022
Validated, scalable, community developed variant calling, RNA-seq and small RNA analysis

Validated, scalable, community developed variant calling, RNA-seq and small RNA analysis. You write a high level configuration file specifying your in

Blue Collar Bioinformatics 915 Dec 29, 2022
A computer algebra system written in pure Python

SymPy See the AUTHORS file for the list of authors. And many more people helped on the SymPy mailing list, reported bugs, helped organize SymPy's part

SymPy 9.9k Jan 08, 2023
PsychoPy is an open-source package for creating experiments in behavioral science.

PsychoPy is an open-source package for creating experiments in behavioral science. It aims to provide a single package that is: precise enoug

PsychoPy 1.3k Dec 31, 2022
Incubator for useful bioinformatics code, primarily in Python and R

Collection of useful code related to biological analysis. Much of this is discussed with examples at Blue collar bioinformatics. All code, images and

Brad Chapman 560 Dec 24, 2022
ckan 3.6k Dec 27, 2022
Float2Binary - A simple python class which finds the binary representation of a floating-point number.

Float2Binary A simple python class which finds the binary representation of a floating-point number. You can find a class in IEEE754.py file with the

Bora Canbula 3 Dec 14, 2021
Animation engine for explanatory math videos

Manim is an engine for precise programatic animations, designed for creating explanatory math videos. Note, there are two versions of manim. This repo

Grant Sanderson 48.9k Jan 03, 2023
Veusz scientific plotting application

Veusz 3.3.1 Veusz is a scientific plotting package. It is designed to produce publication-ready PDF or SVG output. Graphs are built-up by combining pl

Veusz 613 Dec 16, 2022
Python Data Science Handbook: full text in Jupyter Notebooks

Python Data Science Handbook This repository contains the entire Python Data Science Handbook, in the form of (free!) Jupyter notebooks. How to Use th

Jake Vanderplas 36.9k Dec 28, 2022
A simple computer program made with Python on the brachistochrone curve.

Brachistochrone-curve This is a simple computer program made with Python on the brachistochrone curve. I decided to write it after a physics lesson on

Diego Romeo 1 Dec 16, 2021
Program that estimates antiderivatives utilising Maclaurin series.

AntiderivativeEstimator Program that estimates antiderivatives utilising Maclaurin series. Setup: Needs Python 3 and Git installed and added to PATH.

James Watson 3 Aug 04, 2021
Efficient Python Tricks and Tools for Data Scientists

Why efficient Python? Because using Python more efficiently will make your code more readable and run more efficiently.

Khuyen Tran 944 Dec 28, 2022
A modular single-molecule analysis interface

MOSAIC: A modular single-molecule analysis interface MOSAIC is a single molecule analysis toolbox that automatically decodes multi-state nanopore data

National Institute of Standards and Technology 35 Dec 13, 2022
Statsmodels: statistical modeling and econometrics in Python

About statsmodels statsmodels is a Python package that provides a complement to scipy for statistical computations including descriptive statistics an

statsmodels 8.1k Dec 30, 2022
artisan: visual scope for coffee roasters

Artisan Visual scope for coffee roasters WARNING: pre-release builds may not work. Use at your own risk. Summary Artisan is a software that helps coff

Artisan – Visual Scope for Coffee Roasters 705 Jan 05, 2023
A framework for feature exploration in Data Science

Beehive A framework for feature exploration in Data Science Background What do we do when we finish one episode of feature exploration in a jupyter no

Steven IJ 1 Jan 03, 2022