enero 2023 – Página 4

El tipo de las expresiones aritméticas con variables

PorJosé A. Alonso 11-enero-202326-abril-2023

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

La expresión 2*(a+5) puede representarse por

   P (C 2) (S (V 'a') (C 5))

1	P (C 2) (S (V 'a') (C 5))

usando el tipo de las expresiones aritméticas con variables definido como se muestra a continuación.

module Expresion_aritmetica_con_variables where

data Expr = C Int
          | V Char
          | S Expr Expr
          | P Expr Expr
  deriving (Eq, Show)

module Expresion_aritmetica_con_variables where

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

deriving (Eq, Show)

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

La expresión 2*(a+5) puede representarse por

   P(C(2), S(V('a'), C(5)))

1	P(C(2), S(V('a'), C(5)))

usando el tipo de las expresiones aritméticas con variables definido como se muestra a continuación.

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class V(Expr):
    x: str

@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 V(Expr):

x: str

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

Número de variables de una expresión aritmética

PorJosé A. Alonso 10-enero-202330-diciembre-2022

Las expresiones aritméticas construidas con una variable (denotada por X), los números enteros y las operaciones de sumar y multiplicar se pueden representar mediante el tipo de datos Expr definido por

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

data Expr = X

| C Int

| S Expr Expr

| P Expr Expr

Por ejemplo, la expresión X·(13+X) se representa por

   P X (S (C 13) X)

1	P X (S (C 13) X)

Definir la función

   numVars :: Expr -> Int

1	numVars :: Expr -> Int

tal que numVars e es el número de variables en la expresión e. Por ejemplo,

   numVars (C 3)               ==  0
   numVars X                   ==  1
   numVars (P X (S (C 13) X))  ==  2

numVars (C 3) == 0

numVars X == 1

numVars (P X (S (C 13) X)) == 2

Soluciones

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

Soluciones en Haskell

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

numVars :: Expr -> Int
numVars X       = 1
numVars (C _)   = 0
numVars (S a b) = numVars a + numVars b
numVars (P a b) = numVars a + numVars b

data Expr = X

| C Int

| S Expr Expr

| P Expr Expr

numVars :: Expr -> Int

numVars X = 1

numVars (C _) = 0

numVars (S a b) = numVars a + numVars b

numVars (P a b) = numVars a + numVars b

Soluciones en Python

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

def numVars(e: Expr) -> int:
    match e:
        case X():
            return 1
        case C(_):
            return 0
        case S(e1, e2):
            return numVars(e1) + numVars(e2)
        case P(e1, e2):
            return numVars(e1) + numVars(e2)
    assert False

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

def numVars(e: Expr) -> int:

match e:

case X():

return 1

case C(_):

return 0

case S(e1, e2):

return numVars(e1) + numVars(e2)

case P(e1, e2):

return numVars(e1) + numVars(e2)

assert False

Valor de una expresión aritmética con una variable

PorJosé A. Alonso 9-enero-202330-diciembre-2022

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

data Expr = X

| C Int

| S Expr Expr

| P Expr Expr

Por ejemplo, la expresión X·(13+X) se representa por

   P X (S (C 13) X)

1	P X (S (C 13) X)

Definir la función

   valor :: Expr -> Int -> Int

1	valor :: Expr -> Int -> Int

tal que valor e n es el valor de la expresión e cuando se sustituye su variable por n. Por ejemplo,

   valor (P X (S (C 13) X)) 2  ==  30

1	valor (P X (S (C 13) X)) 2 == 30

Soluciones

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

Soluciones en Haskell

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

valor :: Expr -> Int -> Int
valor X         n = n
valor (C a)     _ = a
valor (S e1 e2) n = valor e1 n + valor e2 n
valor (P e1 e2) n = valor e1 n * valor e2 n

data Expr = X

| C Int

| S Expr Expr

| P Expr Expr

valor :: Expr -> Int -> Int

valor X n = n

valor (C a) _ = a

valor (S e1 e2) n = valor e1 n + valor e2 n

valor (P e1 e2) n = valor e1 n * valor e2 n

Soluciones en Python

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

def valor(e: Expr, n: int) -> int:
    match e:
        case X():
            return n
        case C(a):
            return a
        case S(e1, e2):
            return valor(e1, n) + valor(e2, n)
        case P(e1, e2):
            return valor(e1, n) * valor(e2, n)
    assert False

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

def valor(e: Expr, n: int) -> int:

match e:

case X():

return n

case C(a):

return a

case S(e1, e2):

return valor(e1, n) + valor(e2, n)

case P(e1, e2):

return valor(e1, n) * valor(e2, n)

assert False

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

Meses: enero 2023

El tipo de las expresiones aritméticas con variables

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

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

Número de variables de una expresión aritmética

Valor de una expresión aritmética con una variable

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

Entradas recientes

Buscar

Correo electrónico