#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Pyromaths
# Un programme en Python qui permet de créer des fiches d'exercices types de
# mathématiques niveau collège ainsi que leur corrigé en LaTeX.
# Copyright (C) 2006 -- Jérôme Ortais (jerome.ortais@pyromaths.org)
#
# 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
#

from ..outils.Arithmetique import pgcd, ppcm, premier, factoriseTex, carrerise
from ..outils.Affichage import decimaux, decimaux_quiz
from random import randint, shuffle

premiers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
        67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139,
        149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
        227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
        307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383,
        389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
        467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569,
        571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647,
        653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743,
        751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839,
        853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
        947, 953, 967, 971, 977, 983, 991, 997] ## Liste de longueur 168

def Arithmetique():
  """Exercice de décomposition de nombres en facteurs premiers, puis de
  recherche du PGCD et du PPCM, et d'applications aux fractions"""
  quiz = []

  ### Question 1
  exo = ["\\exercice", '\\begin{enumerate}', _(u"\\item Donner la décomposition") +
          _(u" en facteurs premiers des nombres suivants, et préciser quand il") +
          _(u" s\'agit d\'un nombre premier :\\par")]
  cor = ["\\exercice*", '\\begin{enumerate}', _(u"\\item Donner la décomposition")
          + _(u" en facteurs premiers des nombres suivants, et préciser quand il")
          + _(u" s\'agit d\'un nombre premier :\\par")]

  prime = premiers[randint(10,167)]

  fauxpgcd = randint(1,101)
  fauxpgcdfactor = factoriseTex(fauxpgcd)[0]

  complementaires = [randint(6,50), randint(6,50)]
  pgcdcompl = pgcd(complementaires[0], complementaires[1])
  pgcdcomplfact = factoriseTex(pgcdcompl)[0]

  if pgcdcompl != 1:
    facteurs = pgcdcomplfact + fauxpgcdfactor
    facteurs.sort()
  else:
    facteurs = fauxpgcdfactor

  autresnombres = [randint(51,999), randint(51,999)]

  listenombres = [prime, complementaires[0] * fauxpgcd, complementaires[1] *
          fauxpgcd, ] + autresnombres
  melange = [prime, complementaires[0] * fauxpgcd, complementaires[1] *
          fauxpgcd, ] + autresnombres
  shuffle(melange)

  exo.append(decimaux(melange[0]) + " ; " + decimaux(melange[1]) + " ; " +
          decimaux(melange[2]) + " ; " + decimaux(melange[3]) + " ; " +
          decimaux(melange[4]))
  quiz_nom = _(u"PGCD et PPCM: Factoriser")
  quiz_exo = _(u"Écrit la décomposition en facteurs premiers des suivants ")
  quiz_exo += _(u"numéros, et indique quand se traite d'un numéro premier:<br/>\n")
  quiz_exo += _(u"(les facteurs dois les écrire de mineur à majeur)<br/>\n")

  cor.append("\\begin{multicols}{2}")

  for i in range(5):
    cor += factoriseTex(melange[i])[1]
    if len(factoriseTex(melange[i])[2]) > 1:
      text_primes = _(u"~=ne~si")
    else:
      text_primes = _(u"~=si~ne")
    quiz_exo += (_(u"$$%s$$ {1:MULTICHOICE:%s} est premier et est $$%s =$$ ") %
                   (decimaux_quiz(melange[i]), text_primes, decimaux_quiz(melange[i])))
    for j in range(len(factoriseTex(melange[i])[2])):
      if j != len(factoriseTex(melange[i])[2])-1:
        quiz_exo += (u"{1:NUMERICAL:=%s}<sup>{1:NUMERICAL:=%s}</sup>$$\\cdot$$" %
                       tuple(factoriseTex(melange[i])[2][j]))
      else:
        quiz_exo += (u"{1:NUMERICAL:=%s}<sup>{1:NUMERICAL:=%s}</sup><br/><br/>" %
                       tuple(factoriseTex(melange[i])[2][j]))

  cor.append("\\end{multicols}")
  quiz.append([u"cloze", [quiz_nom, quiz_exo, ""]])

  ### Question 2
  exo.append(_(u'\\item En déduire le PGCD et le PPCM des nombres ') +
          decimaux(listenombres[1]) + _(u" et ") + decimaux(listenombres[2]) +
          ".")
  cor.append(_(u'\\item En déduire le PGCD et le PPCM des nombres ') +
          decimaux(listenombres[1]) + _(u" et ") + decimaux(listenombres[2]) +
          ".\\par")

  cor.append(_(u"D'après la question 1), on sait que les nombres ") +
          decimaux(listenombres[1]) + _(u" et ") + decimaux(listenombres[2]) +
          _(u" ont comme facteurs premiers communs : "))
  quiz_nom = _(u"PGCD et PPCM: Calcul")
  quiz_exo = (_(u"En déduire le PGCD et le PPCM des nombres ") +
                decimaux_quiz(listenombres[1]) + _(" et ")
                + decimaux_quiz(listenombres[2]) + ".<br/>\n")

  for j in range(len(facteurs)):
    if j == 0:
      temp = "$"
    if j != len(facteurs)-1:
      temp += decimaux(facteurs[j]) + " , "
    else:
      temp += decimaux(facteurs[j]) + "$.\\par"
  cor.append(temp)

  cor.append(_(u"On en déduit que le PGCD des nombres ") +
          decimaux(listenombres[1]) + _(u" et ") + decimaux(listenombres[2]) +
          _(u" est : "))
  temp = "$"
  if len(facteurs) > 1:
    for j in range(len(facteurs)):
      if j != len(facteurs)-1:
        temp += decimaux(facteurs[j]) + _(" \\times ")
      else:
        temp += decimaux(facteurs[j]) + " = "

  temp+= decimaux(fauxpgcd * pgcdcompl) + ".$\\par"
  cor.append(temp)
  quiz_exo += (_(u"$$PGCD(%s\\, et\\, %s) = $${1:NUMERICAL:=%s}<br/>\n") %
                 (decimaux_quiz(listenombres[1]), decimaux_quiz(listenombres[2]),
                  decimaux_quiz(fauxpgcd * pgcdcompl)))

  vraippcm = (listenombres[1] * listenombres[2]) / (fauxpgcd * pgcdcompl)

  if (listenombres[1] % listenombres[2] == 0):
    cor.append(decimaux(listenombres[1]) + _(u" est un multiple de ") +
            decimaux(listenombres[2]) + _(u", donc leur PPCM est directement ")
               + decimaux(listenombres[1]) + ".")
  elif (listenombres[2] % listenombres[1] == 0):
    cor.append(decimaux(listenombres[2]) + _(u" est un multiple de ") +
            decimaux(listenombres[1]) + _(u", donc leur PPCM est directement ") +
            decimaux(listenombres[2]) + ".")
  else:
    cor.append(_(u"Il existe plusieurs méthodes pour calculer le PPCM de ") +
            decimaux(listenombres[1]) + _(u" et de ") + decimaux(listenombres[2]) +
            ".\\par" )
    cor.append(_(u"En voici deux :"))
    cor.append("\\begin{enumerate}")

    cor.append(_(u"\\item On peut simplement utiliser la formule :"))
    cor.append(_(u"$a \\times b = PGCD(a;~b) \\times PPCM(a;~b)$.\\par"))
    cor.append(_(u"Donc : $PPCM(") + decimaux(listenombres[1]) + ";~" +
        decimaux(listenombres[2]) + ") = " + "\\dfrac{" +
        decimaux(listenombres[1]) + _("\\times") + decimaux(listenombres[2]) + "}{"
        + decimaux(fauxpgcd * pgcdcompl) + "} = " + decimaux(vraippcm) +
        ".$")

    cor.append(_(u"\\item On peut aussi multiplier un nombre par les \"facteurs ")
        + _(u"complémentaires\" de l'autre.\n") + _(u"Ces \"facteurs ") +
        _(u"complémentaires\" sont les facteurs qui complètent le PGCD pour ") +
        _(u"former le nombre.\\par"))

    temp = _(u"Comme $PGCD(") + decimaux(listenombres[1]) + ";~" +\
            decimaux(listenombres[2]) + ") = " + decimaux(fauxpgcd * pgcdcompl)

    if len(facteurs) > 1:
      temp += " = "
      for j in range(len(facteurs)):
        if j != len(facteurs)-1:
          temp += decimaux(facteurs[j]) + _(" \\times ")
        else:
          temp += decimaux(facteurs[j])
    
    factornb1 = factoriseTex(listenombres[1])[0]  
    
    if len(factornb1) > 1:
      textcompl = _(u"$, alors les \"facteurs complémentaires\" de $")
    else:
      textcompl = _(u"$, alors le \"facteur complémentaire\" de $")

    temp += textcompl + decimaux(listenombres[1]) + " = "

    for j in range(len(factornb1)):
      if j != len(factornb1)-1:
        temp += decimaux(factornb1[j]) + _(" \\times ")
      else:
        temp += decimaux(factornb1[j])
        
    factcompl = factoriseTex(listenombres[1] / (fauxpgcd * pgcdcompl))[0]

    if len(factcompl) == 1:
      temp += _(u"$ est : ")
    else:
      temp += _(u"$ sont : ")
    for j in range(len(factcompl)):
      if j != len(factcompl)-1:
        temp += decimaux(factcompl[j]) + " , "
      else:
        temp += decimaux(factcompl[j]) + ".\n"
    temp += _(u"On en déduit que $PPCM(") + decimaux(listenombres[1]) + ";~" +\
            decimaux(listenombres[2]) + ") = " + decimaux(listenombres[2]) +\
            _(" \\times ")

    for j in range(len(factcompl)):
      if j != len(factcompl)-1:
        temp += decimaux(factcompl[j]) + _(" \\times ")
      else:
        temp += decimaux(factcompl[j]) + " = "
    temp += decimaux(vraippcm) + ".$"
    cor.append(temp)
    cor.append("\\end{enumerate}")
    quiz_exo += (_(u"$$PPCM(%s\\, et\\, %s) = $${1:NUMERICAL:=%s}") %
                 (decimaux_quiz(listenombres[1]), decimaux_quiz(listenombres[2]),
                  decimaux_quiz(vraippcm)))
    quiz.append([u"cloze", [quiz_nom, quiz_exo, ""]])

  ### Question 3

  exo.append(_(u"\\item Quel est le plus petit nombre par lequel il faut ") +
          _(u"multiplier ") + decimaux(autresnombres[0]) +
          _(u" pour obtenir un carré parfait ?"))

  cor.append(_(u" \\item Pour obtenir un carré parfait, il faut que sa ") +
          _(u"décomposition en facteurs premiers ne contienne que des facteurs ")
          + _(u"apparaissant un nombre pair de fois. D'après la question 1, ") +
          _(u"la décomposition en facteurs premiers de ")
          + decimaux(autresnombres[0]))
  quiz_nom = _(u"PGCD et PPCM: Carré Parfait")
  quiz_exo = (_(u"Quel est le mineur numéro par le qu'il est nécessaire ") +
          _(u"multiplier ") + decimaux_quiz(autresnombres[0]) +
          _(u" pour obtenir un carré parfait?")+" _____ ")

  decompautre = factoriseTex(autresnombres[0])[1]

  if len(decompautre) == 1:
    cor.append(_(u" est lui-même, car c'est un nombre premier."))
  else:
    cor.append(_(u" est : \\par\n$") + decimaux(autresnombres[0]) + " = " +
            decompautre[-2][5:-2] + ".$\\par")

  cor.append(_(u"Il faut donc encore multiplier ce nombre par "))

  carre = carrerise(autresnombres[0])
  factsup = factoriseTex(carre)[0]

  if len(factsup)==1:
    cor.append(_(u" le facteur "))
  else:
    cor.append(_(u" les facteurs "))

  for j in range(len(factsup)):
    if (j != len(factsup)-1) and (j != len(factsup)-2):
      cor.append(decimaux(factsup[j]) + " , ")
    elif (j == len(factsup)-2):
      cor.append(decimaux(factsup[j]) + _(u" et "))
    else:
      cor.append(decimaux(factsup[j]) + ".\\par")

  cor.append(_(u"Le nombre cherché est par conséquent ") + decimaux(carre) +
          _(u" et le carré parfait obtenu est ") + decimaux(carre *
              autresnombres[0]) + ".")
  quiz_cor = decimaux_quiz(carre,1)
  quiz.append([u"numerical", [quiz_nom, quiz_exo, quiz_cor]])

  ### Question 4
  exo.append(_(u"\\item Rendre la fraction $\\dfrac{") + decimaux(listenombres[1])
          + "}{" + decimaux(listenombres[2]) + _(u"}$ irréductible."))
  quiz_nom = _(u"PGCD et PPCM: Simplification")
  quiz_exo = (_(u"Simplifie la fraction $$\\frac{") + decimaux_quiz(listenombres[1])
          + "}{" + decimaux_quiz(listenombres[2]) + _(u"}$$ à son irréductible.\n"))
  quiz_exo += (_(u"Réponse: $$\\frac{") + decimaux_quiz(listenombres[1])
          + "}{" + decimaux_quiz(listenombres[2]) + u"}=$$ _____ \n")
  quiz_exo += _(u"(Utilise la barre \"/\" pour écrire la fraction)")

  cor.append(_(u"\\item Le moyen le plus rapide de simplifier cette fraction est")
          + _(u"de diviser le numérateur et le dénominateur par leur PGCD.") +
          _(u" D'après la question 2),  PGCD(") + decimaux(listenombres[1]) + ";~"
          + decimaux(listenombres[2]) + ") = "
          + decimaux(fauxpgcd * pgcdcompl) + _(u", donc on obtient :\\par"))
  cor.append(u"$\dfrac{" + decimaux(listenombres[1]) + _("{\\scriptstyle \\div ") +
          decimaux(fauxpgcd * pgcdcompl) + "}}{" + decimaux(listenombres[2]) +
          _("{\\scriptstyle \\div ") + decimaux(fauxpgcd * pgcdcompl) +
          "}} = \dfrac{" + decimaux(listenombres[1] / (fauxpgcd * pgcdcompl)) +
          "}{" + decimaux(listenombres[2] / (fauxpgcd * pgcdcompl)) + "}.$")
  quiz_cor = (decimaux_quiz(listenombres[1] / (fauxpgcd * pgcdcompl)) + "/" +
                decimaux_quiz(listenombres[2] / (fauxpgcd * pgcdcompl)))
  quiz.append([u"shortanswer", [quiz_nom, quiz_exo, quiz_cor]])

  ### Question 5

  num = [randint(6,50), randint(6,50)]
  exo.append(_(u"\\item Calculer $\\dfrac{") + decimaux(num[0]) + "}{" +
          decimaux(listenombres[1]) + "} + \\dfrac{" + decimaux(num[1]) + "}{" +
          decimaux(listenombres[2]) + "}$.")
  quiz_nom = _(u"PGCD et PPCM: Somme")
  quiz_exo = (_(u"Calcule et simplifie: $$\\frac{") + decimaux_quiz(num[0]) + "}{" +
          decimaux_quiz(listenombres[1]) + "} + \\frac{" + decimaux_quiz(num[1]) + "}{" +
          decimaux_quiz(listenombres[2]) + "}=$$ _____ \n")
  quiz_exo += _(u"(Utilise la barre \"/\" pour écrire la fraction)")

  mult1 = vraippcm / listenombres[1]
  mult2 = vraippcm / listenombres[2]

  num1 = mult1 * num[0]
  num2 = mult2 * num[1]

  simplfin = pgcd(num1+num2,vraippcm)

  if simplfin != 1:
    simpl = _("{\\scriptstyle \\div ") + decimaux(simplfin) + "}"
    result = " = \\dfrac{" + decimaux((num1+num2)/simplfin) + "}{" + \
            decimaux((vraippcm)/simplfin) + "}"
    quiz_cor = (decimaux_quiz((num1+num2)/simplfin) + "/" +
                  decimaux_quiz((vraippcm)/simplfin))
  else:
    simpl = ""
    result = ""

  cor.append(_(u"\\item Il faut mettre les fractions au même dénominateur. Grâce")
          + _(u"à la question 2), nous avons déjà un dénominateur commun : ") +
          _(u"le PPCM des nombres ") + decimaux(listenombres[1]) + _(u" et ") +
          decimaux(listenombres[2]) + _(u", qui est par définition le plus petit")
          + _(u"multiple commun de ces deux nombres.\\par"))
  cor.append(u"$\\dfrac{" + decimaux(num[0]) + _("{\\scriptstyle \\times ") +
          decimaux(mult1) + "}}{" + decimaux(listenombres[1]) +
          _("{\\scriptstyle \\times ") + decimaux(mult1) + "}} + \\dfrac{" +
          decimaux(num[1]) + _("{\\scriptstyle \\times ") + decimaux(mult2) + "}}{"
          + decimaux(listenombres[2]) + _("{\\scriptstyle \\times ") +
          decimaux(mult2) + "}} = \\dfrac{" + decimaux(num1) + "}{" +
          decimaux(vraippcm) + "} + \\dfrac{" + decimaux(num2) + "}{" +
          decimaux(vraippcm) + "} = \\dfrac{" + decimaux(num1+num2) + simpl +
          "}{" + decimaux(vraippcm) + simpl + "}" + result + ".$")

  exo.append("\\end{enumerate}")
  cor.append("\\end{enumerate}")
  quiz.append([u"shortanswer", [quiz_nom, quiz_exo, quiz_cor]])

  return (exo,cor,quiz)