Post Reply 
SPN XCAS: MANUAL CALCULO SIMBÓLICO COMPUTACIONAL Y MATEMÁTICA CON XCAS
12-24-2018, 03:14 PM (This post was last modified: 12-28-2018 08:40 PM by compsystems.)
Post: #1
SPN XCAS: MANUAL CALCULO SIMBÓLICO COMPUTACIONAL Y MATEMÁTICA CON XCAS
○ 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.1 25/12/2018
Fuente original en francés e inglés por
Renée De Graeve & Bernard Parisse & Jean-Michel Lecointre.

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/~par...tml#sec201
Frances HP-prime
https://www.hpcalc.org/details/8773
Ingles Xcas:
https://www-fourier.ujf-grenoble.fr/~par...node4.html
Ingles HP-prime:
https://www.hpcalc.org/details/8774

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


◉ 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

SymboLIBRE>https://symbolibre.org/graphics-acceleration-on-the-raspberry-pi-zero.html
Find all posts by this user
Quote this message in a reply
12-25-2018, 09:24 PM (This post was last modified: 12-26-2018 04:19 PM by compsystems.)
Post: #2
RE: SPN XCAS: MANUAL CALCULO SIMBÓLICO COMPUTACIONAL Y MATEMÁTICA CON XCAS
★ 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

SymboLIBRE>https://symbolibre.org/graphics-acceleration-on-the-raspberry-pi-zero.html
Find all posts by this user
Quote this message in a reply
12-26-2018, 04:16 PM (This post was last modified: 12-26-2018 10:23 PM by compsystems.)
Post: #3
RE: SPN XCAS: MANUAL CALCULO SIMBÓLICO COMPUTACIONAL Y MATEMÁTICA CON XCAS
★ 6.2.4 Transformando un conjunto de soluciones en una expresión booleana: list2exp( set[], vars )

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

SymboLIBRE>https://symbolibre.org/graphics-acceleration-on-the-raspberry-pi-zero.html
Find all posts by this user
Quote this message in a reply
Post Reply 




User(s) browsing this thread: 1 Guest(s)