#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
from __future__ import division # 1/2 == .5 (par defaut, 1/2 == 0)

##--------------------------------------#######
#   Mathlib 2 (sympy powered) #
##--------------------------------------#######
#WxGeometrie
#Dynamic geometry, graph plotter, and more for french mathematic teachers.
#Copyright (C) 2005-2007  Nicolas Pourcelot
#
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.
#
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

# version unicode

## Les fonctions qui doivent être accessibles par l'utilisateur final
## "from end_user_functions import *" doit donner un résultat propre.
__classement__ = {
    u"Algèbre": [],
    u"Analyse": [],
    u"Symboles": [],
    u"Arithmétique": [],
    u"Conversions": [],
##    u"LaTeX": [],
}

from universal_functions import *

from custom_functions import derivee


from sympy_functions import expand
developpe = expand
__classement__[u"Algèbre"].append((u"Développe", "developpe", u"Développer une expression."))

from sympy_functions import factor
factorise = factor
__classement__[u"Algèbre"].append((u"Factorise", "factorise", u"Factoriser une expression."))

from sympy_functions import cfactor
cfactorise = cfactor
__classement__[u"Algèbre"].append((u"Factorise dans C", "cfactorise", u"Factoriser une expression dans le corps des complexes."))

from sympy_functions import together
rassemble = together
__classement__[u"Algèbre"].append((u"Une seule fraction", "rassemble", u"Mettre sur le même dénominateur."))

from sympy_functions import evalf
evalue = evalf
__classement__[u"Algèbre"].append((u"Évalue", "evalue", u"Calculer une valeur approchée."))

from sympy import conjugate
conjug = conjugue = conjuguer = conjugate
__classement__[u"Algèbre"].append((u"Conjuguer", "conjug", u"Calculer le conjugué d'un nombre complexe."))

from sympy_functions import sum
somme = sum
__classement__[u"Algèbre"].append((u"Somme", "somme", u"Calculer une somme."))

from sympy_functions import product
produit = product
__classement__[u"Algèbre"].append((u"Produit", "produit", u"Calculer un produit."))

from custom_functions import resoudre
solve = resous = resoudre
__classement__[u"Algèbre"].append((u"Résous", "resous", u"Résoudre une (in)équation ou un système dans R. ex: resous(2x-3>0 et 3x+1<=0"))

from sympy_functions import mat
Matrice = Matrix = Mat = matrix = matrice = mat
__classement__[u"Algèbre"].append((u"Matrice", "mat", u"Génère une matrice. ex: mat([[1,2],[3,4]]), mat(4,4,0), mat(4,4,2*li+3*co)"))


from sympy import isprime
premier = isprime
__classement__[u"Arithmétique"].append((u"Premier ?", "premier", u"Tester si un nombre est premier."))

from sympy_functions import divisors
diviseurs = divisors
__classement__[u"Arithmétique"].append((u"Diviseurs", "diviseurs", u"Chercher les diviseurs d'un nombre."))

# Alias
facteurs = factors = factor
__classement__[u"Arithmétique"].append((u"Facteurs premiers", "facteurs", u"Décomposer un nombre en facteurs premiers."))

from custom_functions import pgcd
gcd = pgcd
__classement__[u"Arithmétique"].append((u"PGCD", "pgcd", u"Calculer le PGCD de plusieurs entiers."))

from custom_functions import ppcm
lcm = ppcm
__classement__[u"Arithmétique"].append((u"PPCM", "ppcm", u"Calculer le PPCM de plusieurs entiers."))

from custom_functions import jhms
hms = jhms
__classement__[u"Conversions"].append((u"Conversion j-h-min-s", "jhms", u"Convertir un temps en secondes en jours, heures, minutes et secondes."))

from custom_functions import frac
__classement__[u"Conversions"].append((u"Convertir en fraction", "frac", u"Convertir un nombre décimal en fraction."))

from sympy import factorial
factoriel = factorial
__classement__[u"Arithmétique"].append((u"Factoriel", "factoriel", u"factoriel(n) vaut 1*2*3*4*5*...*n."))

from sympy import ff
arrangements = nAr = nA = ff
__classement__[u"Arithmétique"].append((u"Arrangements", "nAr", u"Nombre d'arrangements."))

from sympy import binomial
combinaisons = binome = nCr = nC = binomial
__classement__[u"Arithmétique"].append((u"Combinaisons", "nCr", u"Nombre de combinaisons."))

from sympy_functions import limit
lim = limite = limit
__classement__[u"Analyse"].append((u"Limite", "limite", u"Calculer une limite. Ex: 'limite(1/x,x,0+)', 'limite(x^2,x,-oo)'"))

from sympy_functions import diff
derive = diff
__classement__[u"Analyse"].append((u"Dérive", "derive", u"Dériver une expression. Ex: 'derive(2x+7,x)' et 'derive(2x+7,x,2)' (dérivée seconde)"))

from sympy_functions import integrate
integrale = integral = integre = integrate
__classement__[u"Analyse"].append((u"Intègre", "integre", u"Intégrer une expression. Ex: 'integre(x+1,x)' et 'integre(x+1,(x,-1,1))"))

from sympy_functions import series
taylor = series
__classement__[u"Analyse"].append((u"Taylor", "taylor", u"Développement limité. Ex: 'series(cos(x),x,0,5)'"))

from sympy import pi
__classement__[u"Symboles"].append((u"pi", "pi", u"Le nombre pi."))

from sympy import oo
__classement__[u"Symboles"].append((u"oo", "oo", u"L'infini positif."))

from sympy import E
e = E
__classement__[u"Symboles"].append((u"e", "e", u"Le nombre e = exp(1)."))

from sympy import I
i = I
__classement__[u"Symboles"].append((u"i", "i", u"Le nombre imaginaire i."))

##from custom_functions import pstfunc
##__classement__[u"LaTeX"].append((u"Fonction pst-plot", "pstfunc", u"Conversion d'une formule pst-plot en fonction."))


from custom_functions import pstfunc
from graphes import Graphe

#~ class Exp1_bis(sympy.core.numbers.Exp1):
    #~ def tostr(self, level=0):
        #~ return 'e'

#~ e = Exp1_bis()

#~ del Exp1_bis

#~ class ImaginaryUnit_bis(sympy.core.numbers.ImaginaryUnit):
    #~ def tostr(self, level=0):
        #~ return 'i'

#~ i = ImaginaryUnit_bis()

#~ del ImaginaryUnit_bis



