Expresiones aritméticas

Tipo de expresiones aritméticas con una variable

PorJosé A. Alonso 9-enero-202320-abril-2023

1. El tipo de las expresiones aritméticas con una variable en Haskell

La expresión X·(13+X) se representa por

   P(X(), S(C(13), X()))

1	P(X(), S(C(13), X()))

usando el tipo de las expresiones aritméticas con una variable (denotada por X) que se define como se muestra a continuación,

data Expr = C Int
          | V Char
          | S Expr Expr
          | P Expr Expr

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

2. El tipo de las expresiones aritméticas con una variable en Python

La expresión X*(13+X) se representa por

   P(X(), S(C(13), X()))

1	P(X(), S(C(13), X()))

usando el tipo de las expresiones aritméticas con una variable (denotada por X) que se define como se muestra a continuación,

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class X(Expr):
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class X(Expr):

pass

@dataclass

class C(Expr):

x: int

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

Aplicación de una función a una expresión aritmética

PorJosé A. Alonso 6-enero-202316-abril-2023

Usando el tipo de las expresiones aritméticas básicas, definir la función

   aplica :: (Int -> Int) -> Expr -> Expr

1	aplica :: (Int -> Int) -> Expr -> Expr

tal que aplica f e es la expresión obtenida aplicando la función f a cada uno de los números de la expresión e. Por ejemplo,

   λ> aplica (+2) (S (P (C 3) (C 5)) (P (C 6) (C 7)))
   S (P (C 5) (C 7)) (P (C 8) (C 9))
   λ> aplica (*2) (S (P (C 3) (C 5)) (P (C 6) (C 7)))
   S (P (C 6) (C 10)) (P (C 12) (C 14))

λ> aplica (+2) (S (P (C 3) (C 5)) (P (C 6) (C 7)))

S (P (C 5) (C 7)) (P (C 8) (C 9))

λ> aplica (*2) (S (P (C 3) (C 5)) (P (C 6) (C 7)))

S (P (C 6) (C 10)) (P (C 12) (C 14))

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Expresion_aritmetica_basica (Expr(..))

aplica :: (Int -> Int) -> Expr -> Expr
aplica f (C x)     = C (f x)
aplica f (S e1 e2) = S (aplica f e1) (aplica f e2)
aplica f (P e1 e2) = P (aplica f e1) (aplica f e2)

import Expresion_aritmetica_basica (Expr(..))

aplica :: (Int -> Int) -> Expr -> Expr

aplica f (C x) = C (f x)

aplica f (S e1 e2) = S (aplica f e1) (aplica f e2)

aplica f (P e1 e2) = P (aplica f e1) (aplica f e2)

Soluciones en Python

from typing import Callable
from src.expresion_aritmetica_basica import Expr, C, S, P

def aplica(f: Callable[[int], int], e: Expr) -> Expr:
    match e:
        case C(x):
            return C(f(x))
        case S(x, y):
            return S(aplica(f, x), aplica(f, y))
        case P(x, y):
            return P(aplica(f, x), aplica(f, y))
    assert False

from typing import Callable

from src.expresion_aritmetica_basica import Expr, C, S, P

def aplica(f: Callable[[int], int], e: Expr) -> Expr:

match e:

case C(x):

return C(f(x))

case S(x, y):

return S(aplica(f, x), aplica(f, y))

case P(x, y):

return P(aplica(f, x), aplica(f, y))

assert False

Valor de una expresión aritmética básica

PorJosé A. Alonso 5-enero-202316-abril-2023

Usando el tipo de las expresiones aritméticas básicas, definir la función

   valor :: Expr -> Int

1	valor :: Expr -> Int

tal que valor e es el valor de la expresión aritmética e. Por ejemplo,

   valor (P (C 2) (S (C 3) (C 7)))  ==  20

1	valor (P (C 2) (S (C 3) (C 7))) == 20

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Expresion_aritmetica_basica (Expr(..))

valor :: Expr -> Int
valor (C x)   = x
valor (S x y) = valor x + valor y
valor (P x y) = valor x * valor y

import Expresion_aritmetica_basica (Expr(..))

valor :: Expr -> Int

valor (C x) = x

valor (S x y) = valor x + valor y

valor (P x y) = valor x * valor y

Soluciones en Python

from src.expresion_aritmetica_basica import Expr, C, S, P

def valor(e: Expr) -> int:
    match e:
        case C(x):
            return x
        case S(x, y):
            return valor(x) + valor(y)
        case P(x, y):
            return valor(x) * valor(y)
    assert False

from src.expresion_aritmetica_basica import Expr, C, S, P

def valor(e: Expr) -> int:

match e:

case C(x):

return x

case S(x, y):

return valor(x) + valor(y)

case P(x, y):

return valor(x) * valor(y)

assert False

El tipo de las expresiones aritméticas básicas

PorJosé A. Alonso 5-enero-202316-abril-2023

1. El tipo de las expresiones aritméticas básicas en Haskell

La expresión aritmética 2*(3+7) se representa por

   P (C 2) (S (C 3) (C 7))

1	P (C 2) (S (C 3) (C 7))

usando el tipo de dato definido a continuación.

module Expresion_aritmetica_basica where

data Expr = C Int
          | S Expr Expr
          | P Expr Expr

module Expresion_aritmetica_basica where

data Expr = C Int

| S Expr Expr

| P Expr Expr

2. El tipo de las expresiones aritméticas básicas en Python

La expresión aritmética 2*(3+7) se representa por

   P(C(2), S(C(3), C(7)))

1	P(C(2), S(C(3), C(7)))

usando el tipo de dato definido a continuación.

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class C(Expr):

x: int

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

El tipo de las expresiones aritméticas: Valor de una expresión

PorJosé A. Alonso 12-diciembre-202220-abril-2023

Usando el tipo de las expresiones aritméticas, definir la función

   valor :: Expr -> Int

1	valor :: Expr -> Int

tal que valor e es el valor de la expresión e (donde el valor de SiCero e e1 e2 es el valor de e1 si el valor de e es cero y el es el valor de e2, en caso contrario). Por ejemplo,

   valor (Op (Suma (Lit 3) (Lit 5)))      ==  -8
   valor (SiCero (Lit 0) (Lit 4) (Lit 5)) == 4
   valor (SiCero (Lit 1) (Lit 4) (Lit 5)) == 5

valor (Op (Suma (Lit 3) (Lit 5))) == -8

valor (SiCero (Lit 0) (Lit 4) (Lit 5)) == 4

valor (SiCero (Lit 1) (Lit 4) (Lit 5)) == 5

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Tipo_expresion_aritmetica (Expr (..))

valor :: Expr -> Int
valor (Lit n)        = n
valor (Suma x y)     = valor x + valor y
valor (Op x)         = - valor x
valor (SiCero x y z) | valor x == 0 = valor y
                     | otherwise    = valor z

import Tipo_expresion_aritmetica (Expr (..))

valor :: Expr -> Int

valor (Lit n) = n

valor (Suma x y) = valor x + valor y

valor (Op x) = - valor x

valor (SiCero x y z) | valor x == 0 = valor y

| otherwise = valor z

Soluciones en Python

from src.tipo_expresion_aritmetica import Expr, Lit, Op, SiCero, Suma

# 1ª solución
# ===========

def valor(e: Expr) -> int:
    match e:
        case Lit(n):
            return n
        case Suma(x, y):
            return valor(x) + valor(y)
        case Op(x):
            return -valor(x)
        case SiCero(x, y, z):
            return valor(y) if valor(x) == 0 else valor(z)
    assert False

# 2ª solución
# ===========

def valor2(e: Expr) -> int:
    if isinstance(e, Lit):
        return e.x
    if isinstance(e, Suma):
        return valor2(e.x) + valor2(e.y)
    if isinstance(e, Op):
        return -valor2(e.x)
    if isinstance(e, SiCero):
        if valor2(e.x) == 0:
            return valor2(e.y)
        return valor2(e.z)
    assert False

from src.tipo_expresion_aritmetica import Expr, Lit, Op, SiCero, Suma

# 1ª solución

# ===========

def valor(e: Expr) -> int:

match e:

case Lit(n):

return n

case Suma(x, y):

return valor(x) + valor(y)

case Op(x):

return -valor(x)

case SiCero(x, y, z):

return valor(y) if valor(x) == 0 else valor(z)

assert False

# 2ª solución

# ===========

def valor2(e: Expr) -> int:

if isinstance(e, Lit):

return e.x

if isinstance(e, Suma):

return valor2(e.x) + valor2(e.y)

if isinstance(e, Op):

return -valor2(e.x)

if isinstance(e, SiCero):

if valor2(e.x) == 0:

return valor2(e.y)

return valor2(e.z)

assert False

Tipo de expresiones aritméticas con una variable

1. El tipo de las expresiones aritméticas con una variable en Haskell

2. El tipo de las expresiones aritméticas con una variable en Python

Aplicación de una función a una expresión aritmética

Valor de una expresión aritmética básica

El tipo de las expresiones aritméticas básicas

1. El tipo de las expresiones aritméticas básicas en Haskell

2. El tipo de las expresiones aritméticas básicas en Python

El tipo de las expresiones aritméticas: Valor de una expresión

Entradas recientes

Buscar

Correo electrónico