ESPAÑOL: MANUAL CALCULO SIMBÓLICO COMPUTACIONAL Y MATEMÁTICA CON XCAS

Utilisation de Xcas

Modérateur : xcasadmin

compsystems
Messages : 554
Inscription : sam. févr. 04, 2017 11:34 pm
Localisation : Colombia
Contact :

ESPAÑOL: MANUAL CALCULO SIMBÓLICO COMPUTACIONAL Y MATEMÁTICA CON XCAS

Message par compsystems » ven. déc. 28, 2018 4:33 pm

○ Hello, I am translating and expanding the XCAS manual to Spanish, any contribution is welcome. (better examples, better writing, error detection, etc.)

○ Hola, estoy traduciendo y ampliando el manual de XCAS a español, cualquier aporte es bienvenido. (mejores ejemplos, mejor redacción, detección de errores, etc.)

MANUAL CALCULO SIMBÓLICO COMPUTACIONAL Y MATEMÁTICA CON XCAS
Por CompSystems, versión 0.0.3 28/12/2018
Fuente original en francés e inglés por
Renée De Graeve & Bernard Parisse.

PRELIMINAR

Nota:
El símbolo [↵] en este documento significa pulsar la tecla [ENTER] para ejecutar la instrucción, o sentencia.
El operador de asignación usa el dígrafo (:=)
Los símbolos [] es el principal constructo o contenedor de objetos en XCas, además se usa como indicador de extracción de elementos.

TIPOS DE DATOS U OBJETOS EN Xcas

Observemos que los datos 1,2,3 y 4,5,6 entre diferentes contendores y contextos retornan diferentes resultados.

◉ ( 1, 2, 3 ) * ( 4, 5, 6 ) [↵] retorna 720, realiza multiplicación implícita 1*2*3*4*5*6

◉ [ 1, 2, 3 ] * [ 4, 5, 6 ] [↵] retorna 32, se interpreta como producto punto entre vectores

◉ list[ 1, 2, 3 ] * list[ 4, 5, 6 ] [↵] retorna list[ 4, 10, 18 ], se interpreta como producto entre elementos

◉ set[ 1, 2, 3 ] * set[ 4, 5, 6 ] [↵] retorna
set[ tuple[1,4], tuple[1,5], tuple[1,6], tuple[2,4], tuple[2,5], tuple[2,6], tuple[3,4], tuple[3,5], tuple[3,6] ], se interpreta como producto cartesiano entre conjuntos

◉ poly1[ 1, 2, 3 ] * poly1[ 4, 5, 6 ] [↵] retorna poly1[ 4, 13, 28, 27, 18 ], se interpreta como producto entre polinomios

◉ [[ 1, 2, 3 ]] * [[ 4, 5, 6 ]] [↵] retorna "Error: Invalid dimension", la multiplicación de dos matrices A₍n₁, m₁₎ y B₍n₂, m₂₎ debe cumplir que m₁= n₂. [[1,2,3]] tiene como tamaño ₍n₁=1, m₁=3₎ y [[4,5,6]] tiene como tamaño ₍n₂=1, m₂=3₎ por lo tanto m₁ ≠ n₂ ya que 3≠1

◉ [[ 1, 2, 3 ]] * tran([ 4, 5, 6 ]) [↵] retorna matrix[[ 32 ]], ya que tran([ 4, 5, 6 ]) = [[4],[5],[6]] que tiene como tamaño ₍n₂=3,m₂=1₎ por lo tanto m₁ = n₂ ya que 3=3 y el resultado tiene que tener dimensión (n₁, m₂) = (1,1)

Ⅰ) SECUENCIA DE EXPRESIONES U OBJETOS: este objeto en Xcas no requiere un símbolo contenedor que agrupe los elementos o miembros, estos se separan solo por medio de comas (,)

a, b, c es una secuencia de tres objetos, por consiguiente, su tamaño o dimensión es 3.
◉ seq1 := a, b, c [↵]
◉ subtype( seq1 ) [↵] retorna 1, sinónimo de tipo de objeto secuencia
◉ size( seq ) [↵] retorna 3, número de miembros o elementos de la secuencia seq1
◉ dim( seq ) [↵] retorna 3

Para hacer referencia a un miembro individual de una secuencia se requiere primero asignar la secuencia a un nombre identificador de referencia, luego se usan corchetes simples [] si se desea indexarlo o que la ordenación de los miembros se tome desde 0

Por ejemplo, se desea extraer cada elemento de la secuencia definida anteriormente

◉ seq1[ 0 ] [↵] retorna a
◉ seq1[ 1 ] [↵] retorna b
◉ seq1[ 2 ] [↵] retorna c
◉ seq1[ 3 ] [↵] retorna ""Index outside range: … Error: Invalid dimension"

Se usan corchetes dobles [[]] si se desea indexarlo o que la ordenación de los miembros se tome desde 1

◉ seq1[[ 0 ]] [↵] retorna "Error: Invalid dimension"
◉ seq1[[ 1 ]] [↵] retorna a
◉ seq1[[ 2 ]] [↵] retorna b
◉ seq1[[ 3 ]] [↵] retorna c

Aunque también se puede usar paréntesis curvos () para la extracción, no se recomienda el uso de paréntesis, pues generan “confusión” al compilador con la definición de funciones
◉ seq1( 1 ) [↵] retorna a

Algunas ordenes devuelven una secuencia de expresiones, por ej.

◉ qr( [[1,2],[3,4]] ) [↵] retorna dos matrices cada elemento como un numero racional.
matrix[[1/√10,3/5/(√10/5)],[3/√10,-1/5/(√10/5)]],
matrix[[√10,7/5*√10],[0,√10/5]]

◉ evalf( qr([[1,2],[3,4]]) ) [↵] retorna dos matrices
[[-0.316227766017,-0.948683298051],
[-0.948683298051,0.316227766017]],

[[-3.16227766017,-4.42718872424],
[0.0,-0.632455532034]]


Ⅱ) LISTA: es un objeto u arreglo que conserva orden y multiplicidad de los elementos o miembros, los símbolos o corchetes [ ] se usan como contenedores de elementos y para definir una lista, e incluso para vectores o matrices.
[ a, b, c ] es una lista diferente de [ b, a, c ]
◉ list1 := [ a, b, c ]
◉ list2 := [ b, a, c ]
◉ list1 == list2 [↵] retorna false

Ⅲ) VECTOR: como un vector es un arreglo unidimensional, entonces una lista unidimensional se considera un vector.

◉ vect1 := [ a, b, c ] [↵]
◉ type( vect1 ) [↵] retorna 'vector' sinónimo de tipo de objeto DOM_LIST o lista
◉ size( vect1 ) [↵] retorna 3, número de miembros o elementos del vector vect1
◉ dim( vect1 ) [↵] retorna 3

Para hacer referencia a un miembro individual de una lista se usa también corchetes simples o dobles y entre ellos el valor numérico de la posición

Usando corchetes simples

◉ vect1[ 0 ] [↵] retorna a
◉ vect1[ 2 ] [↵] retorna c

Usando corchetes dobles

◉ vect1[[ 1 ]] [↵] retorna a
◉ vect1[[ 3 ]] [↵] retorna c

A diferencia de las secuencias se puede usar los corchetes directamente sobre el vector para extraer sus elementos, por obvias razones no se realiza algún tipo de multiplicación implícita entre arreglos [ a, b, c ] [ 0 ], sino que es interpretado como extracción de elementos.

◉ [ a, b, c ] [ 0 ] [↵] retorna a
◉ [ a, b, c ] [ 2 ] [↵] retorna c
◉ [ a, b, c ] [[ 1 ]] [↵] retorna b
◉ [ a, b, c ] [[ 3 ]] [↵] retorna c

Ⅳ) MATRIZ: una MATRIZ es un arreglo de vectores, donde cada vector debe tener el mismo número de elementos, es decir forman un arreglo bidimensional (rectangular o cuadrado de elementos), donde el número de elementos de cada vector definen el número de columnas que se denotan con la letra m, y el número de vectores definen el número de filas que se denotan con la letra n, por lo tanto el número de elementos del arreglos se obtiene al multiplicar (n*m) o (n*n) si es un arreglo cuadrado ya que m=n
◉ mat1 := [[ a, b ],[ c, d ]] [↵]
por lo tanto
◉ type( mat1 ) [↵] retorna 'vector'
◉ size( mat1 ) [↵] retorna 2, número de filas (n) de la matriz mat1
◉ dim( mat1 ) [↵] retorna [2, 2], número de filas y columnas [n, m] es decir n=2, m=2

Para extraer los elementos de un arreglo se requiere dos posiciones n, m

Usando corchetes dobles

◉ mat1 [[ 1, 1 ]] [↵] retorna a
◉ mat1 [[ 1, 2 ]] [↵] retorna b
◉ mat1 [[ 2, 1 ]] [↵] retorna c
◉ mat1 [[ 2, 2 ]] [↵] retorna d

Usando corchetes simples

◉ mat1 [ 0, 0 ] [↵] retorna a
◉ mat1 [ 0, 1 ] [↵] retorna b
◉ mat1 [ 1, 0 ] [↵] retorna c
◉ mat1 [ 1, 1 ] [↵] retorna d

En un arreglo no matricial no todos los vectores contienen el mismo número de elementos, por lo tanto, no es un arreglo rectangular.

◉ array1 := [[ a, b, c ],[ d ]] [↵]
◉ array1 [[ 1, 1 ]] [↵] retorna a
◉ array1 [[ 1, 2 ]] [↵] retorna b
◉ array1 [[ 1, 3 ]] [↵] retorna c
◉ array1 [[ 2, 1 ]] [↵] retorna d
◉ array1 [[ 2, 2 ]] [↵] retorna "array1(2,2) Error: Invalid dimension"
◉ size( array1 ) [↵] retorna 2, número de filas (n) del arreglo array1
◉ dim( array1 ) [↵] retorna 2, se interpreta como el número de filas ya que el tamaño de las columnas varía en cada fila

Obteniendo el tamaño de cada fila

◉ size( array1[[1]] ) [↵] retorna 3
◉ size( array1[[2]] ) [↵] retorna 1

Ⅴ) CONJUNTO: es un objeto que no conserva orden, como si lo hacen los arreglos de listas, vectores, matrices y polinomios. Cuando se almacena un conjunto en una variable se elimina multiplicidad de los elementos, los símbolos [] más el prefijo (set) se usan como contenedores de elementos para definir un conjunto.
set[ a, b, c ] es una conjunto igual a set[ b, a, c ]
◉ set1 := set[ a, a, b, c ] se elimina la multiplicidad, por lo tanto set1 es igual a set[ a, b, c ]
◉ set2 := set[ b, a, c ]
◉ set1 == set2 [↵] retorna true
◉ subtype( set1 ) [↵] retorna
Usando corchetes simples
◉ set1[ 0 ] [↵] retorna a
◉ set1[ 2 ] [↵] retorna c

Usando corchetes dobles
◉ set1[[ 1 ]] [↵] retorna a
◉ set1[[ 3 ]] [↵] retorna c
◉ size( set1 ) [↵] retorna 3, número de miembros o elementos del conjunto set1
◉ dim( set1 ) [↵] retorna 3

Una secuencia se puede convertir en el contenido de una lista o vector, usando la orden tipo funcional makevector()
◉ seq1 := a, b, c [↵] a, b, c
◉ makevector( seq1 ) [↵] retorna [ a, b, c ]

◉ seq2 := "H", "E", "L", "L", "O" [↵]
◉ makevector( seq2 ) [↵] retorna [ "H", "E", "L", "L", "O" ]

Ⅵ) LISTA {}
Para visualizar una lista de objetos encerrados entre llaves {}, se usan como contenedores los símbolos [] más el prefijo (list)

◉ list[ a, b, c ] [↵] se visualiza como { a, b, c }

Los elementos de las soluciones que arroja las ordenes de resolución por defecto usan list[] para contenerlos, aunque también set[]

◉ solve( x^3 - 6*x² + 11*x -6 = 0, x, '=' ) [↵] retorna set[ x = 1, x = 2, x = 3 ]

mientras que

◉ solve( x^3 - 6*x² + 11*x -6 = 0, x ) [↵] retorna list[ 1, 2, 3 ]

Ⅶ) POLINOMIOS

Un polinomio en una variable está representado por una expresión algebraica simbólica explicita, por defecto en orden decreciente de potencias y de la siguiente forma aₙ*xⁿ+aₙ₋₁*xⁿ⁻¹+...+a₂*x²+a₁*x¹+a₀*x⁰.
◉ increasing_power( 0 ) [↵]
◉ x^3 - 6*x² + 11*x -6 [↵] retorna x^3 - 6*x^2 + 11*x -6
◉ increasing_power() [↵] retorna 0

◉ increasing_power( 1 ) [↵]
◉ x^3 - 6*x² + 11*x -6 [↵] retorna -6+11*x-6*x^2+x^3
◉ increasing_power() [↵] retorna 1

Matemáticamente un polinomio también se puede representar por la lista de sus coeficientes (vector), [aₙ, aₙ₋₁, ..., a₂, a₁, a₀] y en este CAS como poly1[aₙ, aₙ₋₁, ..., a₂, a₁, a₀] en formato vector siempre se escriben los coeficientes asociados a su potencias decrecientes, e incluso si se fija o selecciona el indicador (potencia CRECIENTE en 1), increasing_power(1)
◉ autosimplify( 'simplify' ) [↵] retorna 1
◉ ( x^2 + 2*x +3 ) * ( 4*x^2 + 5*x + 6 ) [↵] retorna 4*x^4 + 13*x^3 + 28*x^2 + 27*x + 18
Se facilita la entrada si se escribe como
◉ poly1[ 1, 2, 3 ] * poly1[ 4, 5, 6 ] [↵] retorna poly1[4, 13, 28, 27, 18]
◉ subtype( poly1[ 1, 2, 3 ] ) [↵] retorna 10
Resumen ejemplos preliminar

( 1, 2, 3 ) * ( 4, 5, 6 );
[ 1, 2, 3 ] * [ 4, 5, 6 ];
list[ 1, 2, 3 ] * list[ 4, 5, 6 ];
set[ 1, 2, 3 ] * set[ 4, 5, 6 ];
poly1[ 1, 2, 3 ] * poly1[ 4, 5, 6 ];
" [[ 1, 2, 3 ]] * [[ 4, 5, 6 ]]";
[[ 1, 2, 3 ]] * tran([ 4, 5, 6 ]);
seq1 := a, b, c;
subtype( seq1 );
size( seq1 );
dim( seq1 );
seq1[ 0 ];
seq1[ 1 ];
seq1[ 2 ];
"seq1[ 3 ]";
"seq1[[ 0 ]]";
seq1[[ 1 ]] ;
seq1[[ 2 ]];
seq1[[ 3 ]];
seq1( 1 );
qr( [[1,2],[3,4]] );
evalf( qr([[1,2],[3,4]]) );
list1 := [ a, b, c ];
list2 := [ b, a, c ];
list1 == list2;
vect1 := [ a, b, c ];
type( vect1 );
size( vect1 );
dim( vect1 );
vect1[ 0 ];
vect1[ 2 ];
vect1[[ 1 ]];
vect1[[ 2 ]];
[ a, b, c ] [ 0 ];
[ a, b, c ] [ 2 ];
[ a, b, c ] [ 1 ];
mat1 := [[ a, b ],[ c, d ]];
type( mat1 );
size( mat1 );
dim( mat1 );
mat1 [[ 1, 1 ]];
mat1 [[ 1, 2 ]];
mat1 [[ 2, 1 ]];
mat1 [[ 2, 2 ]];
mat1 [ 0, 0 ];
mat1 [ 0, 1 ];
mat1 [ 1, 0 ];
mat1 [ 1, 1 ];
array1 := [[ a, b, c ],[ d ]];
array1 [[ 1, 1 ]];
array1 [[ 1, 2 ]];
array1 [[ 1, 3 ]];
array1 [[ 2, 1 ]];
"array1 [[ 2, 2 ]]";
size( array1 );
dim( array1 );
size( array1[[1]] );
size( array1[[2]] );
set1 := set[ a, a, b, c ];
set2 := set[ b, a, c ];
set1 == set2;
set1[ 0 ];
set1[ 2 ];
set1[[ 1 ]];
set1[[ 3 ]];
size( set1 );
dim( set1 );
seq1 := a, b, c;
makevector( seq1 );
seq2 := "H", "E", "L", "L", "O";
makevector( seq2 );
list[ a, b, c ];
solve( x^3 - 6*x² + 11*x -6 = 0, x, '=' );
solve( x^3 - 6*x² + 11*x -6 = 0, x );
increasing_power( 0 );
x^3 - 6*x² + 11*x -6;
increasing_power();
increasing_power( 1 );
x^3 - 6*x² + 11*x -6;
increasing_power();
autosimplify( 'simplify' );
( x^2 + 2*x +3 ) * ( 4*x^2 + 5*x + 6 );
poly1[ 1, 2, 3 ] * poly1[ 4, 5, 6 ];
subtype( poly1[ 1, 2, 3 ] )

[enter]
720,
32,
list[4,10,18],
set[tuple[1,4],tuple[1,5],tuple[1,6],tuple[2,4],tuple[2,5],tuple[2,6],tuple[3,4],tuple[3,5],tuple[3,6]],
poly1[4,13,28,27,18],
"[[ 1, 2, 3 ]] * [[ 4, 5, 6 ]]",
matrix[[32]],
(a,b,c),
1,
3,
3,
a,
b,
c,
"seq1[ 3 ]",
"seq1[[ 0 ]]",
a,
b,
c,
a,
matrix[[1/√10,3/5/(√10/5)],[3/√10,-1/5/(√10/5)]],[[√10,7/5*√10],[0,√10/5]],
matrix[[0.316227766017,0.948683298051],[0.948683298051,-0.316227766017]],[[3.16227766017,4.42718872424],[0.0,0.632455532034]],
[a,b,c],
[b,a,c],
false,
[a,b,c],
vector,
3,
3,
a,
c,
a,
b,
a,
c,
b,
[[a,b],[c,d]],
vector,
2,
[2,2],
a,
b,
c,
d,
a,
b,
c,
d,
[[a,b,c],[d]],
a,
b,
c,
d,
"array1 [[ 2, 2]]",
2,
2,
3,
1,
set[a,b,c],
set[b,a,c],
true,
a,
c,
a,
c,
3,
3,
(a,b,c),
[a,b,c],
"H","E","L","L","O",
["H","E","L","L","O"],
list[a,b,c],
set[x=1,x=2,x=3],
list[1,2,3],
0,
x^3-6*x^2+11*x-6,
0,
1,
x^3-6*x^2+11*x-6,
0,
1,
(x^2+2*x+3)*(4*x^2+5*x+6),
poly1[4,13,28,27,18],
10
session Xcas



✪ Capítulo 6 Funciones del Calculo Simbólico Computacional

Fuente:
Frances Xcas:
https://www-fourier.ujf-grenoble.fr/~pa ... tml#sec201
Frances HP-prime
https://www.hpcalc.org/details/8773
Ingles Xcas:
https://www-fourier.ujf-grenoble.fr/~pa ... node4.html
Ingles HP-prime:
https://www.hpcalc.org/details/8774

★ 6.1 Las constantes simbólicas: e, pi, infinity, inf, i, euler_gamma

[↵] =[enter]

◉ Función exponencial: base del logaritmo natural.
e [↵] retorna exp(1),
Nota: la letra e es un identificador reservado, por esta razón no se puede usar como variable que contenga un objeto.
Sinónimo
%e [↵] retorna exp(1)

◉ Número π: constante circular
Π [↵] retorna π
Sinónimos
pi [↵] retorna π
%pi [↵] retorna π
Nota: pi es un identificador reservado, por esta razón no se puede usar como variable.

◉ Infinito, (no es número, ni un límite)
Infinito real sin signo
infinity [↵] retorna ∞

○ Infinito real positivo
+infinity [↵] retorna +∞
Sinónimo
+inf [↵] retorna +∞
inf [↵] retorna +∞

○ Infinito real negativo
-infinity [↵] retorna -∞
Sinónimo
-inf [↵] retorna -∞

◉ Unidad imaginaria, √-1
i [↵] retorna i
Nota: la letra i es un identificador reservado, por esta razón no se puede usar como variable.

Sinónimo
%i [↵] retorna i
√(-1) [↵] retorna i
sqrt(-1) [↵] retorna i

◉ Constante de Euler γ
euler_gamma [↵] retorna euler_gamma
evalf(euler_gamma) [↵] retorna 0.577215664902
limit(Σ(1/k,k,1,n)-ln(n),n, +infinity) [↵] retorna euler_gamma


✪ 6.2 Booleanos
★ 6.2.1 Constantes booleanas

◉ Booleano Verdadero
true [↵] retorna true
Sinónimos
TRUE [↵] retorna true
evalb(1) [↵] retorna true, para todo número diferente de 0
evalb(-2) [↵] retorna true

◉ Booleano Falso
false [↵] retorna false
Sinónimos
FALSE [↵] retorna false
evalb(0) [↵] retorna false, solo para el valor de 0

◉ Tipo de datos de las constantes
Nota: La orden type() no arroja el tipo de dato o palabra "constante
type(e), type(%e), type(π), type(pi), type(%pi), type(infinity), type(+infinity), type(+inf), type(+inf), type(-infinity), type(-inf), type(i), type(%i), type(euler_gamma), type(limit(sum(1/k,k,1,n)-ln(n),n,+infinity)), type(evalf(euler_gamma)), type(true) [↵] retorna
expression, expression, identifier, identifier, identifier, identifier, expression, expression, expression, expression, expression, complex, complex, identifier, identifier, real, integer

☆ Resumen de ejemplos capítulo 6.1 y 6.2.1
list[
e,
%e,
π,
pi,
%pi,
infinity,
+infinity,
+inf,
-infinity,
-inf,
i,
%i,
√(-1),
sqrt(-1),
euler_gamma,
limit(Σ(1/k,k,1,n)-ln(n),n,+infinity),
evalf(euler_gamma),
true,
TRUE,
evalb(1),
evalb(-2),
false,
FALSE,
evalb(0)
] [↵] retorna

[e, e, π, π, π, ∞, +∞, +∞, -∞, -∞, i, i, i, i, euler_gamma, euler_gamma, 0.577215664902, true, true, true, true, false, false, false]
☆ Prueba online/ test online session Xcas, capítulos 6.1 y 6.2.1


★ 6.2.2 Pruebas o condiciones: operadores infijos ==, ≠, >, ≥, <, ≤

Las pruebas o condiciones (>, ≥, <, ≤) retornan constantes booleanas (true/false) si a y b, es posible finalmente evaluarlos numéricamente, del contrario se mantiene los valores simbólicos en la salida.
a ≥ b devuelve (true) si el operando a es mayor o igual que operando b y (false) en caso contrario.
a > b devuelve (true) si el operando a es estrictamente mayor que el operando b y (false) en caso contrario.
a ≤ b devuelve (true) si el operando a es menor o igual que el operando b y (false) en caso contrario.
a < b devuelve (true) si el operando a es estrictamente menor que el operando b y (false) en caso contrario.
a == b prueba la igualdad entre a y b, y devuelve (true) si a es igual a b y (false) en caso contrario.
a ≠ b devuelve (true) si a es diferente de b y (false) de lo contrario.

◉ ==
Advertencia /!\, el motor computacional en algunas expresiones no pueden comparar la prueba a == b, la salida depende de reagrupar (a-b) no sea 0. Por lo tanto, a == b puede devolver falso incluso si a y b son matemáticamente iguales, de ahí la respuesta del operador infijo == no es concluyente. Use la ordenes de simplificación como simplify() para aumentar la probabilidad de una respuesta correcta.

abs(5) == 5 [↵] retorna true, ya que 5-5==0 es verdadero
pi == 3.14 [↵] retorna false, ya que pi es un numero con infinitos decimales 3.14159265359…..-3.14==0 es falso,
e^(i*π) == -1 [↵] retorna true, ya que e^(i*π) es igual a -1 y -1--1==0 es verdadero
asin(sin(pi/2)) == π/2 [↵] retorna true
abs(3+4*i) == 5 [↵] retorna true
(√(2))² == 2 [↵] retorna true
(√(2.0))² == 2 [↵] retorna false, ya que 2.0 computacionalmente no siempre es igual a 2
(2^(1/2))^2 == 2 [↵] retorna true
1/2 == 2/4 [↵] retorna true

Ejemplos con objetos simbólicos

purge(a, b, x, y) [↵] para eliminar el contenido de las variables a, b, x, y
true == TRUE [↵] retorna true
+infinity == inf, +inf == inf [↵] retorna true, true
e^x == exp(x) [↵] retorna true
a == b [↵] retorna false
a = b [↵] no retorna un valor booleano, ya que se interpreta como una igualdad o ecuación, y si el lado izquierdo es un identificador se realiza una asignación. Para mantener una expresión de la forma a=b y no ser interpretada como una asignación se usa la orden hold() o quote(), como también se puede usar comillas simples
hold( a=b ), quote( a=b ), 'a=b',

◉ ≠, ≥, ≤, sinónimos !=, >=, <=
pi ≠ 3.14 [↵] retorna true
3/4 ≥ 0.75 [↵] retorna true
1/2 ≤ 0.5 [↵] retorna true

◎ Ejemplos con objetos simbólicos
a ≠ b [↵] retorna true
a ≥ b [↵] retorna la expresión sin probar a >= b
a ≤ b [↵] retorna la expresión sin probar y se reescribe de la forma b >= a

◉ >, <
1/2 > 3/4 [↵] retorna false
-0.681534914418 < 0.681534914418 [↵] retorna true
π^e-e^π < abs(π^e-e^π) [↵] retorna true

a < b [↵] retorna la expresión sin probar y se reescribe de la forma b > a
a > b [↵] retorna la expresión sin probar a > b

◉ Verificación de una igualdad (=) con la orden evalb
evalb( e^(i*pi) = -1 ) [↵] retorna true
evalb( pi = 3.14 ) [↵] retorna false

☆Resumen de ejemplos capítulo 6.2.2
list[
abs(5) == 5,
pi == 3.14,
e^(i*π) == -1,
asin(sin(pi/2)) == π/2,
abs(3+4*i) == 5,
(√(2))² == 2,
(√(2.0))² == 2,
(2^(1/2))^2 == 2,
1/2 == 2/4,
purge(a, b, x, y),
true==TRUE,
+infinity == inf,
+inf == inf,
e^x == exp(x),
a == b,
hold( a=b ),
quote( a=b ),
'a=b',
pi ≠ 3.14,
3/4 ≥ 0.75,
1/2 ≤ 0.5,
a ≠ b,
a ≥ b,
a ≤ b,
1/2 > 3/4,
-0.681534914418 < 0.681534914418,
π^e-e^π < abs(π^e-e^π),
a < b,
a > b,
evalb( e^(i*pi) = -1 ),
evalb( pi = 3.14 )] [↵] retorna

list[true, false, true, true, true, true, false, true, true, "No such variable a", "No such variable b", "No such variable x", "No such variable y", true, true, true, true, false, a=b, a=b, a=b, true, true, true, true, a>=b, b>=a, false, true, true, b>a, a>b, true, false]

☆ Prueba online/ test online session Xcas, capítulos 6.2.2






















★ 6.2.4 Transformando un conjunto de soluciones en una expresión booleana: list2exp( set[], vars )
Las transformaciones de soluciones facilitan la manipulación de expresiones en diferentes contextos, por ej. simplifica la sustitución para la verificación de las respuestas obtenidas por los solucionadores.
La orden list2exp() devuelve
☆ Caso 1: Si el primer argumento u operando es un conjunto de soluciones de la forma
set[ (var = expresión0), (var = expresión1), … (var = expresiónN) ] retorna una expresión booleana de la forma
(var = expresión0) or (var = expresión1) or … (var = expresiónN)

◎ solve( x^3 - 6*x² + 11*x -6 =0, x, '=' ) [↵] retorna
set[x = 1, x = 2, x = 3]

◉ list2exp( set[x = 1, x = 2, x = 3], x ) [↵] retorna
x=1 or x=2 or x=3

☆ Caso 1.1: si el primer argumento u operando es un conjunto de soluciones de la forma
list[ expresión0, expresión1, … expresiónN ] retorna una expresión booleana de la forma
(var = expresión0) or (var = expresión1) or … (var= expresiónN)

◎ solve( x^3 - 6*x² + 11*x -6 =0, x ) [↵] retorna
list[1, 2, 3]
◉ list2exp( list[1, 2, 3], x ) [↵] retorna
x=1 or x=2 or x=3

☆ Caso 2: si el primer argumento u operando es un conjunto de soluciones de la forma
set[
[ var1 = expresión0, var2= expresión1 ],
[ var1 = expresión3, var2= expresión4 ], …
[ var1 = expresión, var2= expresiónM ] ] retorna una expresión booleana de la forma
(var = expresión0) or (var = expresión1) or … (var= expresiónN)

◎ solve([x^2 + y^2 = 5, x^2 - y^2 = 1],[x,y],'=') [↵] retorna
set[ [x=√(3), y=√(2)],
[x=-√(3),y=√(2)],
[x=√(3),y=-√(2)],
[x=-√(3),y=-√(2)]]

◉ list2exp( set[ [x=√(3), y=√(2)], [x=-√(3),y=√(2)], [x=√(3),y=-√(2)], [x=-√(3),y=-√(2)]], [x, y] ) [↵] retorna
(x=√3 and y=√2) or (x=-√3 and y=√2) or (x=√3 and y=-√2) or (x=-√3 and y=-√2)

◎ solve( sin(t) = sin(2*t), t, '=' ) [↵] retorna
set[ t=(-pi/3), t=0, t=(pi/3), t=pi ]

◉ list2exp( set[ t=(-pi/3), t=0, t=(pi/3), t=pi ],t ) [↵] retorna
t=-pi/3 or t=0 or t=pi/3 or t=pi

● Orden relacionada: exp2list()

★ 6.2.5 Transformando una expresión booleana (conjunto solución) en una lista de soluciones: exp2list( expresion_booleana )

La orden exp2list() devuelve

☆ Caso 1: si el argumento u operando es una expresión booleana de la forma
(var = expresión0) or (var = expresión1) or … (var = expresiónN) retorna una lista de soluciones de la forma
[ expresion0, expresion1, …, expresionN ]
Es decir, exp2list() elimina el lado izquierdo de la igualdad y las disyunciones (o) y finalmente las agrupa en un lista.

◉ exp2list( x=1 or x=2 or x=3 ) [↵] retorna [1,2,3]

☆ Caso 2: si el argumento u operando es una expresión booleana de la forma
(var1 = expresión0 and var2= expresión1) or (var1 = expresión3 and var2= expresión4) or … (var1 = expresiónN and var2= expresiónM) retorna una lista de listas de soluciones de la forma
[ [expresion0, expresion1], [expresion2, expresion3], …, [expresionN, expresionM] ]
Es decir, exp2list() elimina el lado izquierdo de la igualdad, las conjunciones (y) y disyunciones (o) y finalmente las agrupa en un lista de listas.

◉ exp2list( (x=√3 and y=√2) or (x=-√3 and y=√2) or (x=√3 and y=-√2) or (x=-√3 and y=-√2) ) [↵] retorna
[ [√(3), √(2)],
[-√(3), √(2)],
[√(3), -√(2)],
[-(√(3)), -√(2)] ]

● Orden relacionada: list2exp()

☆ Resumen de ejemplos capítulo 6.2.4/5
list[ exp2list( x=1 or x=2 or x=3 ),
exp2list( (x=√3 and y=√2) or (x=-√3 and y=√2) or (x=√3 and y=-√2) or (x=-√3 and y=-√2) ),
solve( x^3 - 6*x² + 11*x -6 =0, x, '=' ),
list2exp( set[x = 1, x = 2, x = 3], x ),
solve( x^3 - 6*x² + 11*x -6 =0, x ),
list2exp( list[1, 2, 3], x ),
solve([x^2 + y^2 = 5, x^2 - y^2 = 1],[x,y],'='),
list2exp( set[ [x=√(3), y=√(2)], [x=-√(3),y=√(2)], [x=√(3),y=-√(2)],[x=-√(3),y=-√(2)]], [x,y] ),
solve( sin(t) = sin(2*t), t, '=' ),
list2exp( set[ t=(-pi/3), t=0, t=(pi/3), t=pi ],t ) ]

☆ Prueba online/ test online
session Xcas, capítulos 6.2.4/5























2.24 Polinomios

2.24.1 Convertir coeficientes de un polinomio a simbólico, orden poly2symb(vector_de_coeficientes, [variable])
La orden poly2symb sirve para convertir una lista de coeficientes de un polinomio univariable a su expresión simbólica, poly2symb es afectado por el indicador o bandera autosimplify()

Argumentos:
Un primer argumento es una lista de coeficientes de un polinomio (por orden decreciente) y el segundo argumento es opcional, puede ser un nombre de variable simbólica (si se omite por defecto el SAC usa la variable x), el segundo argumento también puede ser un numero/expresión ó variable = numero/expresión

Salida:
poly2symb transforma el argumento(s) en un polinomio simbólico. Dependiendo del indicador SIMPLIFICAR (Ninguno, Mínimo, Máximo) la salida se muestra factorizada o desarrollada (expandida) parcial o completamente. Si el segundo argumento es un numero/expresión se evaluará el polinomio en ese valor, o si indica la variable = numero/expresión, se muestra un polinomio como una ecuación y el lado derecho el valor evaluado


Caso 1: si el indicador SIMPLIFICAR es seleccionado como Ninguno, es decir autosimplify(0) [↵]
◉ poly2symb(poly1[ 1, -6, 11, -6 ], x) devuelve ((x-6)*x+11)*x-6 que es una expresión sin simplificar.

Caso 2: si el indicador SIMPLIFICAR es seleccionado como Mínimo, es decir autosimplify(1) [↵]
como el primer argumento espera un vector se puede eliminar en este caso el prefijo poly1
◉ poly2symb([ 1, -6, 11, -6 ], x) devuelve x*(x*(x-6)+11)-6 que es una expresión con un nivel mínimo de simplificación.

Caso 3: si el indicador SIMPLIFICAR es seleccionado como Máximo, es decir autosimplify(2) [↵]
◉ poly2symb([ 1, -6, 11, -6 ], x) devuelve x^3-6*x^2+11*x-6 que es una expresión con un nivel máximo de simplificación.
◉ solve( poly2symb([ 1, -6, 11, -6 ])=0, x, '=' ) [↵] retorna set[ x = 1, x = 2, x = 3 ]

◉ poly2symb([1,2,3]) * poly2symb(poly1[4,5,6]) [↵] retorna 4*x^4+13*x^3+28*x^2+27*x+18
◉ (x^2+2*x+3)*(4*x^2+5*x+6) [↵] retorna 4*x^4+13*x^3+28*x^2+27*x+18

◉ poly2symb([ 1, -6, 11, -6 ], x=5) devuelve (x^3-6*x^2+11*x-6) = 24, ya que 5³-6*5²+11*5-6 = 24
◉ poly2symb([ 1, -6, 11, -6 ], 5) devuelve 24
◉ poly2symb([ 1, -6, 11, -6 ], 1-i) devuelve -3-i, ya que ((1-i)³-6*(1-i)²+11*(1-i)-6) = 3-i
◉ poly2symb([ 1, -6, 11, -6 ], y+3) devuelve y³+3*y²+2*y ya que (y+3)³-6*(y+3)^2+11*(y+3)-6 = y³+3*y²+2*y
◉ poly2symb([ 1, -6, 11, -6 ], 3) devuelve 0, es decir es una raíz del polinomio
◉ poly2symb([ 1, -6, 11, -6 ], 1) devuelve 0, es decir es una raíz del polinomio
◉ poly2symb([ 1, -6, 11, -6 ], 2) devuelve 0, es decir es una raíz del polinomio
◉ poly2symb(x^3-6*x^2+11*x+6); devuelve x^3-6*x^2+11*x+6 no genera error si la entrada es una expresión polinómica

Un código para automatizar la simplificación a valor máximo y mostrar la multiplicación de dos polinomios
f():={
if autosimplify()=='Nop' or autosimplify()=='regroup' then autosimplify('simplify');increasing_power(true); end;
poly2symb([1,2,3])*poly2symb([4,5,6]);
}:;

2.24.2 Convertir polinomio simbólico a coeficientes, orden: symb2poly (expr,[variable])

Répondre