Sympy

Sympy è un pacchetto di manipolazione simbolica open source, scritto in Python puro.
L'obiettivo di Sympy è quello di diventare un completo CAS in Python, mentre il codice viene mantenuto il più semplice possibile in modo che possa essere facilmente estensibile e comprensibile

Caratteristiche :.

• aritmetica di base *, /, +, -
• semplificazione di base (come a * b * b + 2 * b * a * b - & gt; 3 * a * b ^ 2)
• espansione (come (a + b) ^ 2 - & gt; a ^ 2 + 2 * a * b + b ^ 2)
• funzioni (exp, ln, sin, cos, tan, ...)
• numeri complessi (come exp (I * x) .evalc () - & gt; cos (x) + I * sin (x))
• differenziazione
• serie di Taylor
• sostituzione di base (come X & gt; ln (x))
• interi a precisione arbitraria e razionali
• standard (python) galleggia

Cosa c'è di nuovo in questa versione:.

• SymPy ora supporta Python 3 e PyPy
• Questa versione include anche importanti nuove funzionalità di calcolo combinatorio, l'integrazione definitiva, variabili casuali, espressioni matrice, set, meccanica classica, meccanica quantistica, algebra commutativa, plottaggio, e la geometria differenziale.
• Ci sono stati anche centinaia di correzioni di bug durante l'intera base di codice.

Cosa c'è di nuovo nella versione 0.7.1:

• I maggiori cambiamenti:
• Python 2.4 non è più supportato. SymPy non funziona affatto in Python 2.4. Se hai ancora bisogno di utilizzare SymPy sotto Python 2.4 per qualche motivo, è necessario utilizzare SymPy 0.7.0 o precedente.
• La biblioteca tramando Pyglet è ora (opzionale) dipendenza esterna. In precedenza, abbiamo spedito una versione di Pyglet con SymPy, ma questo era vecchio e buggy. Il piano è quello di rendere finalmente il tracciato in SymPy molto più modulare, in modo che supporta molti backend, ma questo non è stato ancora fatto. Per ora, ancora solo Pyglet è direttamente supportato. Si noti che Pyglet è solo una dipendenza opzionale ed è necessaria solo per la stampa. Il resto della SymPy può ancora essere utilizzato senza dipendenze (ad eccezione di Python).
• isympy ora funziona con il nuovo IPython 0,11.
• mpmath è stato aggiornato alla 0.17. Vedere le corrispondenti note di rilascio mpmath a http://mpmath.googlecode.com/svn/trunk/CHANGES.
• Aggiunta di un oggetto Subs per rappresentare sostituzioni non valutate. Questo, infine, ci consente di rappresentare i derivati ​​valutati in un punto, vale a dire, diff (f (x), x) .subs (x, 0) restituisce Subs (derivata (f (_x), _x), (_x,), (0, )). Ciò significa anche che SymPy può ora di calcolare correttamente la regola di quando è richiesto questa funzionalità, come ad esempio con la f (g (x)). Diff (x).
• funzioni ipergeometriche / Meijer G-Functions:
• classi aggiunte iper () e meijerg () per rappresentare ipergeometriche e Meijer funzioni G, rispettivamente. Essi supportano valutazione numerica (usando mpmath) e differenziazione simbolica (non rispetto ai parametri).
• Aggiunto un algoritmo per la riscrittura G-funzioni ipergeometriche e Meijer in termini di più familiari, denominate funzioni speciali. È accessibile tramite la funzione hyperexpand (), o anche via expand_func (). Questo algoritmo riconosce molte funzioni elementari, e anche funzioni complete e incomplete gamma, funzioni Bessel e funzioni di errore. Può essere facilmente esteso per gestire più classi di funzioni speciali.
• Sets:
• class Aggiunto FiniteSet di imitare il comportamento set pitone, mentre anche l'interazione con intervalli esistenti e sindacati
• FiniteSets e intervalli interagiscono in modo che, ad esempio intervallo (0, 10) - FiniteSet (0, 5) produce (0, 5) U (5, 10]
• FiniteSets anche gestire oggetti non numerici in modo che segue è possibile {1, 2, 'uno', 'due', {a, b}}
• Aggiunto ProductSet gestire prodotti cartesiani di set
• Creare usando l'operatore *, cioè twodice = FiniteSet (1, 2, 3, 4, 5, 6) * FiniteSet (1, 2, 3, 4, 5, 6) o quadrato = intervallo (0, 1) * Intervallo (0, 1)
• operatore pow funziona anche come ci si aspetta: R3 = Intervallo (-oo, oo) ** 3; (3, -5, 0) in R3 == True
• sottrazione, unione, misura tutto il lavoro prendendo intersezioni complesse conto.
• Aggiunto metodo as_relational ai set, producendo dichiarazioni booleane utilizzando And, Or, Eq, Lt, Gt, etc ...
• reduce_poly_inequalities Cambiato per tornare unioni di serie piuttosto che gli elenchi di set
• iterabili:
• Aggiunto generare routine per le partizioni interi e partizioni binarie. La routine per divisori interi prende 3 argomenti, il numero stesso, l'elemento massimo consentito nelle partizioni generati e il numero massimo possibile di elementi che saranno nella partizione. Partizioni binari sono caratterizzati da contiene solo potenze di due.
• Aggiunto generazione di routine per le partizioni multi-set. Dato un multiset, l'algoritmo implementato genera tutte le possibili partizioni di che il multi-set.
• Aggiunto generare routine per permutazioni campana, disordini, e involuzioni. Una permutazione campana è uno in cui i cicli che compongono consistono di interi in ordine decrescente. Un derangement è una permutazione tale che l'elemento i-esimo non è nella posizione esimo. L'involuzione è una permutazione che moltiplicato per se stesso dà la permutazione identità.
• Aggiunta la generazione di routine per collane illimitati. Una collana senza restrizioni è una stringa a-ario di n caratteri, ognuno su un massimo di tipi. Questi sono stati caratterizzati dai parametri n e k nella routine.
• Aggiunta la generazione di routine per le foreste orientati. Si tratta di una implementazione di algoritmi S in TAOCP Vol 4A.
• xyz basi Spin:
• Il rappresentate, riscrivere e logica InnerProduct è stato migliorato per lavorare tra due basi di spin. Ciò è stato fatto utilizzando la matrice Wigner-D, implementato nella classe WignerD, nel definire le variazioni tra le varie basi. Rappresentando uno stato, cioè rappresentano (JzKet (1,0), base = Jx), può essere usato per dare il vettore rappresentazione di qualsiasi ottenere in qualsiasi basi x / y / z per valori numerici di j e m nella centrifuga autostato. Allo stesso modo, riscrittura stati in basi diverse, cioè JzKet (1,0) .rewrite ('Jx'), scriveranno gli stati come combinazione lineare degli elementi di base data. Poiché questo si basa sulla funzione rappresentare, questo funziona solo per valori j e m numerici. Il prodotto interno di due autostati in diverse basi può essere valutata, cioè InnerProduct (JzKet (1,0), JxKet (1,1)). Quando si usano due diverse basi, uno stato viene riscritta nel altra base, quindi questo richiede valori numerici di j e m, ma innerproducts degli stati nella stessa base può ancora essere fatto simbolicamente.
• I metodi Rotation.D e Rotation.d, che rappresentano la funzione di Wigner-D e la funzione di piccolo-d Wigner, restituire un'istanza della classe WignerD, che può essere valutata con il metodo doit () per dare la matrice corrispondente elemento della matrice Wigner-D.
• Altre modifiche:
• Ora usiamo MathJax nei nostri documenti. MathJax rende LaTeX matematica entierly nel browser con Javascript. Ciò significa che la matematica è molto più leggibile rispetto al precedente matematica png, che usa le immagini. MathJax è supportata solo su browser moderni, così LaTeX matematica nella documentazione potrebbe non funzionare su browser più vecchi.
• nroots () ora consente di impostare la precisione dei calcoli
• Aggiunto il supporto per i tipi gmpy e mpmath di per sympify ()
• correggere alcuni bug con lambdify ()
• Correggere un bug con i simboli as_independent e non commutativa.
• Correggere un bug con collect (edizione 2516)
• Molte correzioni relative al porting SymPy a Python 3. Grazie al nostro studente GSoC Vladimir Peric, questo compito è quasi completata.
• Alcune persone sono state retroattivamente aggiunta al file AUTORI.
• Aggiunto un risolutore per un caso particolare dell'equazione Riccati nel modulo ODE.
• derivati ​​iterati sono piuttosto stampate in modo conciso.
• Correggere un bug con l'integrazione di funzioni con più DiracDeltas.
• Aggiungi supporto per Matrix.norm () che funziona per matrici (non solo vettori).
• I miglioramenti all'algoritmo basi di Groebner.
• Plot.saveimage supporta ora una StringIO outfile
• Expr.as_ordered_terms ora supporta ordinamenti non lex.
• diff ora canonicalizes l'ordine dei simboli di differenziazione. Questo è così si può semplificare espressioni come f (x, y) .DIFF (x, y) - f (x, y) .DIFF (y, x). Se si desidera creare un oggetto Derivative senza ordinare le args, è necessario creare esplicitamente con Derivative, in modo che si otterrà Derivata (f (x, y), x, y)! = Derivata (f (x, y), y, x). Si noti che internamente, i derivati ​​che possono essere calcolate sono sempre calcolati nell'ordine in cui sono dati in.
• funzioni aggiunti is_sequence () e iterable () per determinare se qualcosa è un iterabile o normale iterabile rispettivamente.
ordinato
• Enabled un'opzione Sfinge che aggiunge un link fonte accanto a ciascuna funzione, che collega ad una copia del codice sorgente per tale funzione.

Cosa c'è di nuovo nella versione 0.7.0:

• Si tratta di una major release che aggiunge molte nuove funzionalità .
• Il cambiamento più grande è il nuovo poligoni, che sono molto più potenti e molto più veloce. Questo colpisce molte parti del SymPy, compresi i solutori e la semplificazione.
• Un altro grande cambiamento è il nuovo modulo di quantum, che è stata aggiunta in seguito a due Google Summer of Code progetti.
• Oltre a questi grandi cambiamenti, ci sono molti cambiamenti nel corso tutti SymPy.
• Questa versione dispone anche di un paio di minori per lo più pause di compatibilità all'indietro.

Cosa c'è di nuovo nella versione 0.6.3:

• portato su python2.6 (tutti i test passano) e Jython (tutti i test passano ad eccezione di quelli a seconda della & quot; ast & quot; il modulo).
• True divisione è stato fissato (tutti i test passano con il & quot; -Qnew & quot; opzione Python)
.
• buildbot.sympy.org è stato creato; sympy è ora regolarmente testato su Python 2.4, 2.5, e 2.6 su entrambi i386 e amd64.
• py.bench:. Comparativa basata py.test-
• bin / test: un semplice framework di test py.test-simili, senza dipendenze esterne e con uscita ben colorato
.
• La maggior parte dei limiti ora funzionano.
• fattorizzazione su Z [x] è stata notevolmente migliorata.
• è stata aggiunta la funzione a tratti. nsimplify () è stato realizzato.
• Simboli e sintassi var sono stati unificati.
• stampa di codice C.

Requisiti :

• Python