PRESENTACION DE INTEGRACION NUMERICA

HOY NOS TOCO HABLAR EN LA CLASE DE LA INTEGRACION NUMERICA

DECIDIMOS USAR EL METODO DE INTEGRACION DE SIMPSON

DICHA PRESENTACION ES LA SIGUIENTE

SI COMPRENDO QUE ES UN POCO COMPLICADO ESTE METODO PERO ES DIVERTIDO

GRACIAS QUE TENGAS UN EXELENTE DIA!!!!!

PROGRAMA LOGICO

HOLA!!! YO TOME EL PROBLE QUE SE LLAMA DONDE QUEDO EL PESCADO O FALTA EL PESCADO Y DICE:

2 PADRES MIRAN A SUS HIJOS PESCAR. CADA HOMBRE Y SU HIJO ATRAPARON UN PEZ, PERO CUANDO VOLVIERON AL CAMPAMENTO SÓLO HABIA TRES PESCES.
¿CÓMO PUEDE SER ESTO?
(NINGUNO DE LOS PECES SE COMIERON, PERDIERON O REGRESARON)

PUES SOLO FUERON TRES PERSONAS, EL ABUELO, EL PADRE Y EL HIJO.

pescado(X):-abuelo(X),padre(X),hijo(X).
abuelo(X):- pescado(x).
padre(X):- pescado(X).
hijo(X):- pescado(X).
lostres(pescado).
nadie(pescado).

?lostres(pescado)
true

GRACIAS QUE TENGAN UN GOOD DAY!!!!

LENGUAJES FUNCIONALES

EN LOS LENGUAJES FUNCIONALES DECIDI UTILIZAR HASKELL
ES UN POCO COMPLICADO LA VERDADA SU CODIFICACION
PERO LES PRESENTO LA SERIE GEOMETRICA UNA DE LAS PROGRECIONES MATEMATICAS
La Serie Geometrica está constituida por una secuencia de elementos en la que cada uno de ellos se obtiene multiplicando el anterior por una constante denominada razón o factor de la progresión. Se suele reservar el término progresión cuando la secuencia tiene una cantidad finita de términos mientras que se usa sucesión cuando hay una cantidad infinita de términos, si bien, esta distinción no es estricta.
Así,  es una progresión geométrica con razón igual a 3, porque:
15 = 5 × 3
45 = 15 × 3
135 = 45 × 3
405 = 135 × 3
y así sucesivamente.

El codigo en Haskell seria el siguiente:
module Geometric (geo, geo') where
import qualified Data.Ratio as R
data Geo = Geo Rational deriving (Eq, Ord, Show)
instance Num Geo where 
(+)    (Geo a) (Geo b)    = Geo (a + b) 
(*)    (Geo a) (Geo b)    = Geo (a * b) 
(-)    (Geo a) (Geo b)    = Geo (a - b) 
abs    (Geo a)            = Geo (abs a) 
signum (Geo a)            = Geo (signum a) 
fromInteger               = Geo . toRational
instance Real Geo where  toRational (Geo a)= toRational a
instance Fractional Geo where 
(/)    (Geo a) (Geo b)    = Geo (a / b) 
fromRational              = Geo
instance RealFrac Geo where 
properFraction (Geo a)    = case properFraction a of (i, f) -> (i, Geo f)
tmap2 :: (a -> b) -> (a, a) -> (b, b)
tmap2 f (x, y) = (f x, f y)
geo :: (Fractional n) => [Geo] -> [n]
geo = map (fromRational . toRational)
geo' :: (Integral n) => [Geo] -> [n]
geo' = map truncate . geo
def_factor = 2
instance Enum Geo where 
succ           (Geo n)  = Geo $ succ n 
pred           (Geo n)  = Geo $ pred n 
toEnum                  = Geo . toEnum 
fromEnum       (Geo n)  = fromEnum n 
enumFrom       n        = enumFromThen n (n * def_factor) 
enumFromThen   n n'     = let q = n' / n in iterate (* q) n 
enumFromTo     n end    = enumFromThenTo n (n * def_factor) end 
enumFromThenTo n n' end   
| n  > end             = []  
| n' > end             = [n]   
| otherwise            = takeWhile (<= end) $ enumFromThen n n'

La otra serie que tome fue la del Fcatorial en Perl
En este lenguaje es mas sencillo, almenos no se aplican tantas funciones
Su codigo es el siguiente
#factorial

$input=<>;
sub factorial
{
$s=1;
$r=1;
 while ($s <= $input)
 {
   $r *= $s;
   $s++;
 }
if($input == 0)
{
 $r=0;
}
return $r;
}
print "The result is".$r;
ESPERO LES HAYA GUSTADO!!! ESPERO COMENTARIOS

CORRIGIENDO EL LENGUAJE A LISP EL FACTORIAL SERIA:

(defun factorial (n)

    (if (= n 0)

    1

    (* n (factorial (- n 1)))
    )
)