From 9b760104181e77306bef1811f584d13b6c4657a9 Mon Sep 17 00:00:00 2001 From: Jean-Christophe Jameux Date: Fri, 4 Mar 2022 14:25:00 +0100 Subject: [PATCH] =?UTF-8?q?Un=20peu=20de=20m=C3=A9nage?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/GenerateurDeProblemes.elm | 10 +- ...t.elm => ParserExpressionMathematique.elm} | 90 +++--- src/ParserMaths.elm | 282 ------------------ 3 files changed, 42 insertions(+), 340 deletions(-) rename src/{ParserMathsPratt.elm => ParserExpressionMathematique.elm} (68%) delete mode 100644 src/ParserMaths.elm diff --git a/src/GenerateurDeProblemes.elm b/src/GenerateurDeProblemes.elm index 54129ca..b5d75d6 100644 --- a/src/GenerateurDeProblemes.elm +++ b/src/GenerateurDeProblemes.elm @@ -12,7 +12,7 @@ import Fraction as F exposing (Fraction) import Html exposing (Attribute, Html, button, div, iframe, input, p, section, textarea) import List as L import Parser as P exposing (..) -import ParserMathsPratt as PM +import ParserExpressionMathematique as Pem import Random import Random.Extra import Random.List @@ -455,14 +455,14 @@ voirTexteVariable txtvar = Variable var -> let expressionParseePotentielle = - PM.parseMaths var + Pem.parserExpressionMathematique var in case expressionParseePotentielle of Err erreur -> "L'expression est mal formée." Ok expressionParsee -> - case Result.map F.teX <| PM.evaluer <| expressionParsee of + case Result.map F.teX <| Pem.resultatFractionnaire <| expressionParsee of Ok a -> a @@ -568,7 +568,7 @@ variableAremplacer = aRemplacer : Parser Aremplacer aRemplacer = - succeed (\x y -> Aremplacer x (L.map (F.asciiMath << PM.evaluerBis) y)) + succeed (\x y -> Aremplacer x (L.map (F.asciiMath << Pem.evaluerUnsafe) y)) |. espaces |= variable { start = Char.isAlpha @@ -582,7 +582,7 @@ aRemplacer = , separator = "," , end = "" , spaces = espaces - , item = PM.expr + , item = Pem.expressionMathematique , trailing = P.Optional } diff --git a/src/ParserMathsPratt.elm b/src/ParserExpressionMathematique.elm similarity index 68% rename from src/ParserMathsPratt.elm rename to src/ParserExpressionMathematique.elm index 6ac2ded..77bb0dc 100644 --- a/src/ParserMathsPratt.elm +++ b/src/ParserExpressionMathematique.elm @@ -1,10 +1,8 @@ -module ParserMathsPratt exposing - ( Expr(..) - , evaluer - , evaluerBis - , expr - , montrerErreurs - , parseMaths +module ParserExpressionMathematique exposing + ( ExpressionMathematique(..) + , evaluerUnsafe + , expressionMathematique + , parserExpressionMathematique , resultatFractionnaire ) @@ -15,34 +13,34 @@ import Pratt exposing (constant, infixLeft, infixRight, literal, postfix, prefix import Set -type Expr +type ExpressionMathematique = Entier Int | Decimal Float - | Oppose Expr - | Somme Expr Expr - | Difference Expr Expr - | Produit Expr Expr - | Quotient Expr Expr - | Reste Expr Expr - | Exp Expr Expr - | Cos Expr - | Sin Expr - | Tan Expr - | ArcCos Expr - | ArcSin Expr - | ArcTan Expr - | Log Expr - | Ln Expr - | Factorielle Expr - | Degre Expr - | Poly (List Expr) String + | Oppose ExpressionMathematique + | Somme ExpressionMathematique ExpressionMathematique + | Difference ExpressionMathematique ExpressionMathematique + | Produit ExpressionMathematique ExpressionMathematique + | Quotient ExpressionMathematique ExpressionMathematique + | Reste ExpressionMathematique ExpressionMathematique + | Exp ExpressionMathematique ExpressionMathematique + | Cos ExpressionMathematique + | Sin ExpressionMathematique + | Tan ExpressionMathematique + | ArcCos ExpressionMathematique + | ArcSin ExpressionMathematique + | ArcTan ExpressionMathematique + | Log ExpressionMathematique + | Ln ExpressionMathematique + | Factorielle ExpressionMathematique + | Degre ExpressionMathematique + | Poly (List ExpressionMathematique) String | E | Pi -parseMaths : String -> Result (List DeadEnd) Expr -parseMaths source = - run expr source +parserExpressionMathematique : String -> Result (List DeadEnd) ExpressionMathematique +parserExpressionMathematique source = + run expressionMathematique source montrerErreurs : String -> List DeadEnd -> String @@ -75,8 +73,8 @@ montrerAttendu err = "une expression" -evaluerBis : Expr -> Fraction.Fraction -evaluerBis expression = +evaluerUnsafe : ExpressionMathematique -> Fraction.Fraction +evaluerUnsafe expression = case resultatFractionnaire expression of Err _ -> { numerateur = 666, denominateur = 1 } @@ -85,11 +83,7 @@ evaluerBis expression = a -evaluer = - resultatFractionnaire - - -resultatFractionnaire : Expr -> Fraction.Resultat +resultatFractionnaire : ExpressionMathematique -> Fraction.Resultat resultatFractionnaire expression = let f opperation a b = @@ -124,14 +118,8 @@ resultatFractionnaire expression = Err "BOOM" -expr : Parser Expr -expr = - succeed identity - |= mathExpression - - -mathExpression : Parser Expr -mathExpression = +expressionMathematique : Parser ExpressionMathematique +expressionMathematique = Pratt.expression { oneOf = [ constant (keyword "E") E @@ -159,15 +147,11 @@ mathExpression = , postfix 6 (symbol "!") Factorielle , postfix 6 (symbol "°") Degre ] - , spaces = espaces + , spaces = Parser.spaces } -espaces = - Parser.chompWhile <| (==) ' ' - - -expressionEntreParentheses : Pratt.Config Expr -> Parser Expr +expressionEntreParentheses : Pratt.Config ExpressionMathematique -> Parser ExpressionMathematique expressionEntreParentheses config = succeed identity |. symbol "(" @@ -175,8 +159,8 @@ expressionEntreParentheses config = |. symbol ")" -poly : Parser Expr -poly = +polynome : Parser ExpressionMathematique +polynome = succeed Poly |. keyword "Poly" |. spaces @@ -185,7 +169,7 @@ poly = , separator = "," , end = "]" , spaces = spaces - , item = lazy (\_ -> mathExpression) + , item = lazy (\_ -> expressionMathematique) , trailing = Forbidden } |. spaces diff --git a/src/ParserMaths.elm b/src/ParserMaths.elm deleted file mode 100644 index 89c50e3..0000000 --- a/src/ParserMaths.elm +++ /dev/null @@ -1,282 +0,0 @@ -module ParserMaths exposing (evaluer, evaluerBis, expr, montrerErreurs, parseMaths) - -import Fraction as F exposing (Fraction, Resultat, fraction, map2) -import Maybe as M -import Parser exposing (..) -import Set - - -montrerErreurs : String -> List DeadEnd -> String -montrerErreurs source errs = - case List.head errs of - Nothing -> - "" - - Just firstErr -> - source - ++ "\n" - ++ String.repeat (firstErr.col - 1) " " - ++ "^" - ++ "\nL'algorithme attendait :" - ++ String.join - " ou " - (List.map montrerAttendu errs) - - -montrerAttendu : DeadEnd -> String -montrerAttendu err = - case err.problem of - ExpectingNumber -> - "un nombre entier" - - ExpectingSymbol s -> - "un \"" ++ s ++ "\"" - - _ -> - "une expression" - - -evaluerBis : Expr -> Fraction -evaluerBis expression = - case evaluer expression of - Err _ -> - { numerateur = 666, denominateur = 1 } - - Ok a -> - a - - -evaluer : Expr -> Resultat -evaluer expression = - case expression of - Add a b -> - map2 F.somme (evaluer a) (evaluer b) - - Sub a b -> - map2 F.difference (evaluer a) (evaluer b) - - Mul a b -> - map2 F.produit (evaluer a) (evaluer b) - - Div a b -> - map2 F.quotient (evaluer a) (evaluer b) - - Exp a b -> - map2 F.exp (evaluer a) (evaluer b) - - Neg a -> - Result.map F.oppose (evaluer a) - - Grouping l -> - evaluer l - - Entier n -> - F.fraction n 1 - - Poly a_i x -> - Err "Les polynômes ne sont pas encore pris en charge." - - -type Expr - = Add Expr Expr - | Sub Expr Expr - | Mul Expr Expr - | Div Expr Expr - | Exp Expr Expr - | Neg Expr - | Entier Int - | Grouping Expr - | Poly (List Expr) String - - -parseMaths : String -> Result (List DeadEnd) Expr -parseMaths source = - run expr source - - -expr : Parser Expr -expr = - add - - -type Operator - = MulOp - | DivOp - | AddOp - | SubOp - | ExpOp - - -type Operand - = NoOperand - | Operand Operator Expr - - -{-| En quelque sorte, décurryfie une expression binaire -binary e\_1 (Operand MulOp e\_2) == Mul e\_1 e\_2 --} -binary : Expr -> Operand -> Expr -binary a b = - case b of - NoOperand -> - a - - Operand op e -> - case op of - MulOp -> - Mul a e - - DivOp -> - Div a e - - AddOp -> - Add a e - - SubOp -> - Sub a e - - ExpOp -> - Exp a e - - -add : Parser Expr -add = - succeed - foldBinary - |= mul - |. spaces - |= loop [] addHelper - - - --- - - -foldBinary : Expr -> List Operand -> Expr -foldBinary left operands = - List.foldr - (\operand expression -> binary expression operand) - left - operands - - -addHelper : List Operand -> Parser (Step (List Operand) (List Operand)) -addHelper operands = - oneOf - [ succeed (\right -> Loop (Operand AddOp right :: operands)) - |. symbol "+" - |. spaces - |= lazy (\_ -> mul) - , succeed (\right -> Loop (Operand SubOp right :: operands)) - |. symbol "-" - |. spaces - |= lazy (\_ -> mul) - , succeed () - |> map (\_ -> Done operands) - ] - - -mul : Parser Expr -mul = - succeed - foldBinary - |= exp - |. spaces - |= loop [] mulHelper - - -mulHelper : List Operand -> Parser (Step (List Operand) (List Operand)) -mulHelper operands = - oneOf - [ succeed (\right -> Loop (Operand MulOp right :: operands)) - |. symbol "*" - |. spaces - |= lazy (\_ -> exp) - , succeed (\right -> Loop (Operand DivOp right :: operands)) - |. symbol "/" - |. spaces - |= lazy (\_ -> exp) - , succeed () - |> map (\_ -> Done operands) - ] - - -exp : Parser Expr -exp = - succeed - binary - |= primary - |. spaces - |= oneOf - [ succeed (Operand ExpOp) - |. symbol "^" - |. spaces - |= lazy (\_ -> exp) - , succeed NoOperand - ] - - -primary : Parser Expr -primary = - succeed - (\op literal -> - case op of - Nothing -> - literal - - Just _ -> - Neg literal - ) - |= oneOf - [ succeed Just - |= symbol "-" - , succeed Nothing - ] - |= oneOf - [ grouping - , poly - , nombre - ] - - -nombre : Parser Expr -nombre = - succeed Entier - |= number - { int = Just identity - , hex = Nothing - , octal = Nothing - , binary = Nothing - , float = Nothing - } - - -poly : Parser Expr -poly = - succeed Poly - |. keyword "Poly" - |. spaces - |= sequence - { start = "[" - , separator = "," - , end = "]" - , spaces = spaces - , item = lazy (\_ -> expr) - , trailing = Forbidden - } - |. spaces - |= variable - { start = \_ -> True - , inner = \_ -> False - , reserved = Set.fromList [] - } - - -grouping : Parser Expr -grouping = - succeed Grouping - |. symbol "(" - |. spaces - |= lazy (\_ -> expr) - |. spaces - |. symbol ")"