μ blog : octubre 2021

martes, 26 de octubre de 2021

Representación gráfica de la banda de Möbius con MAXIMA

Un ejemplo de uso de MAXIMA para obtener el desarrollo de Taylor de una función dada

Un procedimiento básico para resolver sistemas de ecuaciones lineales con MAXIMA

Selección de la precisión con MAXIMA

Un ejemplo de manipulación simbólica con MAXIMA

Uso de MAXIMA como ayuda para detectar la no existencia del límite global de una función real de una variable real en un punto dado. Un ejemplo

Interpolación de Lagrange con MAXIMA. Un ejemplo

Dos ejemplos de representación gráfica de curvas paramétricas con MAXIMA

lunes, 25 de octubre de 2021

Raíz n-ésima de un número complejo

[Raíz n-ésima de un número complejo]

Demostración de la fórmula de De Moivre por inducción, sin tener que emplear la fórmula de Euler

Demostración de la fórmula de De Moivre por el método de inducción

Fórmula de De Moivre y fórmula de Euler

Ecuación de una circunferencia en R^3 que resulta de la intersección de una esfera y un plano

[ Circunferencia en R^3 como intersección de una esfera y un plano ] (2020)

Algunos ejercicios de descomposición de endomorfismos. Forma de Jordan

[Unos cuantos ejercicios resueltos]

Ejemplo de cálculo de la matriz de Jordan y de la matriz de paso con MAXIMA

Ejemplo de cálculo de los valores propios y del polinomio mínimo asociado a una matriz dada con MAXIMA

viernes, 15 de octubre de 2021

Corba envolupant, corves involutes i evolutes / curva envolvente, corves involuta y evoluta

Vaig escriure ja fa molt de temps aquest breu apunt. Un exemple que podem esmentar fa referència al problema del llençament paràbolic: l'envolupant de la familia de trajectories parabòliques que s'obtenen en variar l'angle de llençament es una altra paràbola, que, per raons obvies, s'anomena paràbola de seguretat. $\square$

La espiral de Cornú (clotoide)

Escribí hace tiempo estos apuntes. Véase la gráfica de esta curva, así como los cálculos que he realizado con MAXIMA para dibujarla, en las figuras de abajo (Figura 1 en el texto de los apuntes).

Figura 1

$\square$

viernes, 8 de octubre de 2021

Redondeo

Recordemos que la operación de redondeo de un número real $x$ se define así: $\mathcal{R}(x;n)=\text{Ent}(b^n \times 0.m+\mu)\times b^{e-n}$, donde $b$ es la base de numeración y $e$ es el valor del exponente en la notación científica en coma flotante $0.m\times b^e$ (siendo $m$ los dígitos de la mantisa), y $\mu$ representa media unidad en la base de trabajo. Veamos un ejemplo de redondeo, conservando $n:=4$ cifras/dígitos significativos para el caso $\sqrt{5}=2.236067977\ldots=0.2236067977\ldots\times 10^1$. Luego, $e:=1$ (exponente de la potencia), y,como $b:=10$, la media unidad es $\mu:=0.5$.

SOLUCIÓN.
Entonces, $\mathcal{R}(\sqrt{5};4)=\text{Ent}(10^4\times 0.2236067977\ldots+0.5)\times 10^{1-4}=$
$=\text{Ent}(2236.067977\ldots+0.5)\times 10^{-3}$
$=\text{Ent}(2236.567977\ldots)\times 10^{-3}$
$=2236\times 10^{-3}$
$=2.236$
$=0.2236\times 10^1$

El máximo error de redondeo, también llamado presición de la máquina, o unidad de redondeo, viene dado por $\dfrac{1}{2}\,b^{e-n}$, que, en nuestro caso es $\dfrac{1}{2}\cdot 10^{1-4}=\dfrac{1}{2}\cdot 10^{1-4}=0.0005$
$\square$

Representación IEEE Standard 754 en punto flotante

Actualmente, la representación que usan la mayoría de los computadores es la llamada IEEE Standard 754 en punto flotante. Está basada en los tres elementos que se ha mencionado antes: signo, mantisa y exponente. Si la base es binaria, $b=2$, el primer dígito (dígito principal) es, siempre, $1$, esto es, $d_1=1$, por lo que no haría falta almacenarlo en memoria (en cuyo caso nos referiríamos a él como dígito principal implícito).

En precisión simple, el estándard utiliza $32$ bits ($4$ bytes), de los cuales $8$ bits ($1$ byte) es para el exponente $E$ (representando números enteros no negativos que varían entre $0$ y $255$, esto es, los que se pueden codificar en base $2$ con $8$ bits); $23$ bits son para la parte fraccionaria, $F$, y $1$ bit para el signo, $S$. Cada bit almacena un $0$ o bien un $1$. Así, el valor asignado a una representación es $$(-1)^{S}\times 2^{E-127} \times \mathbb{1}.F$$

Se utiliza un sesgo de $127$ aplicado al valor del exponente almacenado $E$, dando lugar al exponente verdadero $E-127$, lo cual tiene como finalidad el poder representar tanto exponentes positivos como negativos; de este modo, un valor almacenado $E$ representa el valor verdadero $E-127$.

Como ya hemos visto que $E$ varía entre $0$ y $255$, entonces $E-127$ toma valores en el conjunto de $2^8=256$ elementos: $\{-127,-126,\ldots,0,1,2,\ldots,128\}$, y , por tanto, $2^{E-127}$ varía entre $2^{-127}\approx 10^{-38}$ y $2^{128}\approx 10^{38}$.

El ordinal de cada término de la sucesión $-127,-126,\ldots,0,1,2,\ldots,128$ (empezando a contar desde $0$) se denomina característica. El valor de la característica varía pues de $0$ (para el valor del primer término $-127$) a $255$ (para el valor del último término $128$), y representa el valor del exponente almacenado $E$.

Designando por $n$ al número de bits del campo del exponente (en nuestro caso $n:=8$), esta característica es igual, por tanto, al valor del exponente verdadero $E-127$ más lo que viene a denominarse desplazamiento y que es fácil ver que es igual a $2^{n-1}-1$. Así por ejemplo, si el exponente verdadero es $E-127:=100$, entonces el valor de la característica es $100+2^{8-1}-1=100+128-1=227$; y (otro ejemplo), como seria de esperar si $E-127:=-127$, entonces sus característica es igual a $-127+2^{8-1}-1=-127+128-1=0$; y si $E-127:=-128$, entonces su característica es igual a $128+2^{8-1}-1=128+128-1=255$, que es el último término de la sucesión que hemos comentado.

Por otra parte, El bit del signo es $0$ para positivos y $1$ para negativos.

Ejemplo 1.
Consideremos la representación de un cierto número (veremos cuál es al final) en el estándar IEEE 754 de simple precisión (32 bits) $$\underset{\overbrace{1\; \text{bit para el signo}}}{1}\quad \underset{\overbrace{8\; \text{bits para el exponente}}}{01010011} \quad\underset{\overbrace{23\; \text{bits para la mantisa}}} {10011110\; 00101000\; 0101000}$$ es tal que:

i) El signo es negativo por ser el valor del bit $S$ igual a $1$, y, por tanto, $(-1)^S=(-1)^1=-1$

ii) la mantisa $1.F$ es

1+$(1\cdot 2^{-1}+0\cdot 2^{-2}+0\cdot 2^{-3}+1\cdot 2^{-4}+\overset{\underbrace{23}}{\ldots}+0\cdot 2^{-22}+0\cdot 2^{-23})$
donde a partir del segundo sumando se expresa la cantidad $F$, siendo el primer sumando a la izquierda, el primer uno, que viene de la notación $1.F$, luego la mantisa corresponde al número $$\dfrac{2097151}{1048576}$$

iii) El exponente verdadero de la potencia $2^{E-127}$ es igual a 0$1010011_{2}$, o lo que es lo mismo 0b$1010011$ — en base $2$ los números suelen empezar por 0 o bien por 0b— corresponde a $83_{10}-127=-44$
Por tanto, la representación estándard indicada da el valor

$$-( \dfrac{2097151}{1048576} ) \times 2^{83-127}$$ es decir $$-( \dfrac{2097151}{1048576} ) \times 2^{-44} \approx -0.1136868\times 10^{-12}$$ pues con $23$ bits de mantisa el número de dígitos/cifras significativas correctas que podemos asegurar es de $7$

-oOo-

Nota: En doble precisión, se reservan $11$ bits es para representar el exponente $E$, donde el sesgo es ahora de $2^{11-1}-1=2^{10}-1=1023$.
-oOo- Referencias:
[1] Moreno, C.: Introducción al Cálculo Numérico, UNED, Madrid, 2011
[2] García Valle, J.L.: Matemáticas especiales para computación, McGraw-Hill, Madrid, 1988

Caligrama: Tozudos sueños

                        Entre rutas
         tan lejanas,                  añoradas
       ignoradas,                       andan
      olvidadas,                         algunas ideas  
       indiferentes                     errantes 
        a las cosas,                   en tozudos sueños,
         al tiempo                    deambulando  
                       tan ausentes

               © Joan Aranes Clua
               Madrid, octubre de 2021

viernes, 1 de octubre de 2021

Punto interior/exterior a una circunferencia. Un ejercicio de programación en C/C++

//-----------------------------------------------------------------
// Verificació de condicions amb operadors relacionals 
//
// Joan Aranès Clua
// data: 15/12/2001
// 
// Pertany el punt (x,y) al cercle de centre (a,b)  i radi r ?
//-----------------------------------------------------------------

#include <stdio.h>
#include <math.h>

void main ()

{

  double a,b,r,x,y;
  double dist2;//distància euiclidiana al quadrat entre P(x,y) i O(a,b)

    
  //definició de la circumferència -> cercle
  printf("-----------------------------------\n");
  printf("Definiu una circumfer\x08Ancia donant el centre i el radi:\n");
  printf("introdu\x08Bu les coordenades del centre de la 
     circumfer\x08Ancia: a i b, separades per un espai:\n");
    scanf("%lf %lf",&a, &b);
  printf("introdu\x08Bu el valor del radi de la circumfer\x08Ancia r:\n");
    scanf("%lf",&r);

  
  //definició del punt P(x,y) interior o exterior a la circumferència
  printf("-----------------------------------\n");
  printf("Pertany el punt P(x,y) al cercle de centre O(a,b) i radi r ?\n");
  printf("introdu\x08Bu les coordenades del punt P: x i y, 
     separades per un espai:\n");
    scanf("%lf %lf",&x, &y);
  
  printf("\n");
  printf("Si el punt P \x082s interior a la c. escriur\x085 un 1,en cas\n");
  printf("contrari escriur\x085 un 0 ....\n");
  printf("\n");
  
  // càlcul de la distància al quadrat entre el centre de la c. i el punt	
  dist2=pow((x-a),2)+pow((y-b),2);

  printf("resposta:\n");
  printf("%d\n",dist2<=pow(r,2));

  }

El algoritmo 3n+1. Conjetura de Collatz. Un ejercicio de programación en C/C++

//-----------------------------------------------------------------
// CICLE d'un nombre enter. L'algoritme 3n+1  
// 
// Joan Aranès Clua
// data: 17/12/2001
// 
// Aquest programa calcula el "cicle" d'un nombre n
// el qual es calcula de la manera següent:
// 1. s'entra n 
// 2. es mostra n 
// 3. si n =1 
// 4.   aleshores ACABA EL PROGRAMA  
// 5. si n es senar aleshores n:=3n+1 
// 6. en cas contrari, és a dir, si n és parell, aleshores n:=n/2 
// 7. tornar a la línia 2 
//---------------------------------------------------------------------
// exemple 1. cicle(22) = {22, 11, 34, 17, 52, 26, 13, 
                          40, 20, 10, 5, 16, 8, 4, 2, 1}
// es tracta d'un cicle de longitud 16
// --------------------------------------------------------------------
// EXEMPLES AMB POTÈNCIES DE ^2: 2^x
// exemple 2. cicle(32) = {32, 16, 8, 4, 2, 1}
// exemple 3. cicle(64) = {64, 32, 16, 8, 4, 2, 1}
// ...
// exemple 4. cicle(1024) = {1025, 512, 256, 128, 
                            64, 32, 16, 8, 4, 2, 1}
// ...
//    Cal observar que:
//		1r Efectivament, les longituds dels cicles de les potències de 2 
           són relativament curtes
//      2n longitud_del_cicle(2^x) = x+1
//-----------------------------------------------------------------

#include <stdio.h>          //printf i scanf
#include <stdlib.h>         //system() .. per a la f. cls

void main()
{

    int n;  // variable corresponent a la dada d'entrada
    int m;  // variable auxiliar
	int longitud; // variable per mesurar la longitud del cicle

    system("cls"); //esborra la pantalla

	// entrada dels coeficients
	printf("\nintrodu\x08Bu un nombre enter:\n");
    printf("n=");
	scanf("%d",&n);
	printf("\ncicle(%d)=",n);

	m=n;
	longitud=1;
	while (m>1)
	{
		printf("%d ",m);
		if ((m%2)!=0) 
			m=3*m+1;
		else 
			m=m/2;
		longitud=longitud+1;
		
    }
	printf("%d ",m);
		
	printf("\nlongitud del cicle(%d)=%d",n,longitud);
	printf("\n\n");
}

Encriptación de un texto por sustitución monoalfabética. Un ejercicio en C/C++

//////////////////////////////////////////
// Còpia encriptada per substitució monoalfabètica
// Joan Aranès Clua
// 7/04/2002
//////////////////////////////////////////


// MANEIG DE L'EXECUTABLE:
//
// Cal posar-nos a la consola del DOS 
// i anar al directori on es troba l'executable m8e1.exe
// seguint els següents passos:
// 1. generem un fitxer de prova fent, per exemple,
//	1.1.: %>copy con prova.txt
//			aixo es una prova
//          CTRL+Z (insereix la marca de final d'arxiu EOF)
// 2. executem el programa que genará un segon arxiu amb el missatge encriptat 
//    el nom del qual haurem de triar (p.ex: 'arxiu2.txt') fent: 
//	2.1.: %>m8e1 prova.txt prova2.txt
// 3. comprovar el contingut del fitxer generat 
//        %>type prova2.txt




    #include <stdio.h>
	#include <ctype.h>

    
	void main(int argc, char *argv[]){
         FILE *origen, *desti;
         char car;
		 int codi; //codi de substitució


         if(argc!=3){
            printf("S'ha d'especificar arxiu origen i arxiu destí\n");
            return;
         }

		 printf("\n\nintroduïu el codi (0-25)...\n");
		 scanf("%d", &codi);

         origen=fopen(argv[1],"rb");//fitxer de lectura i binari
         desti=fopen(argv[2],"wb");// fitxer d'escriptura i binari
         if (origen==NULL || desti==NULL){
             printf("no es pot realitzar l'operació\n");
             return;
         } 
         car=getc(origen);
         while(!feof(origen)) 
			 // llegeix en el fitxer origen fins trobar
			 // la marca EOF de final d'arxiu
		 {
			 if (car!=' ') 
				 // si no es tracta d'un espai en blanc 			    				 
				{
				 car =(tolower(car)-97+codi)%26+97;
				}
           putc(car,desti); // també copia els espais 
           car=getc(origen);
         }
         fclose(origen);
         fclose(desti);
     }

μ blog