martes, 31 de enero de 2017

Bug de gedit "pygi-argument.c:1583"

Si desea simplemente saber como solucionar su problema, dirigirse a la sección de posibles soluciones, en caso de querer conocer un poco de como me quitó horas de sueño este bug, puede continuar leyendo.

Hace algún tiempo que trabajo en Ubuntu, y me gusta usar el editor gedit para realizar mis scripts. Por azares de la vida, y cuestiones de configuraciones, al editar documentos para compilar con Latex,  estos parecen seguir sus propios caprichos y no se dejan editar, pues al intentar abrir tales documentos, el programa se cierra abruptamente.

Revisando el todo poderoso google hallé que el bug no solo era mio, pues al buscar usando el mensaje de error que es:

ERROR:../../gi/pygi-argument.c:1583:_pygi_argument_to_object: code should not be reached

Hallé varios resultados, y uno de ellos me llamó la atención, en ese momento supuse que tenía algo que ver con la codificación del texto, y me fijé en algo curioso, que los documentos que tenían problemas eran guardados con la codificación de windows para el carácter de fin de linea, aunque el capricho seguía, luego de ahondar más, el problema era en algunos de esos archivos. Luego de hacer mejor la tarea, y recordando algunos tips de la programación de scripts, recordé aquelo de "Algunos compiladores no reconocen bien la última línea del código", efectivamente, por ese motivo (bien o mal fundado) acostumbro poner varias lineas en blanco al final de los scripts.

Cuando parecía que había dado con el error, solo fue una falsa esperanza. Revisando a lupa de detalle, reduje mi archivo a un documento con letras 'a', y al final un símbolo '¿', se guardó el archivo que contenía justo 8193 bytes, en formato UTF-8, y el error desaparecía si quitaba byte (8192 bytes). Después de varias pruebas entendí que la codificación de dicho carácter genera el error, pero con la particularidad de que si o solo si se halla en una posición de memoria precisa, el byte 8191 (0x1fff) y 8192(0x2000), pues en UTF-8 '¿' se escribe con dos bytes (0xC2 0xBF), de tal suerte que si antes de tal carácter se suprime o agrega algo, el error desaparecía.

Luego, analicé el archivo del foro desde el cual partieron mis sospechas, ese archivo si que es corto (7 bytes), en hexadecimal corresponde a:

20 67 73 69 C4 0D 0A

Si somos "expertos" (sarcasmo) con formatos de textos, podemos deducir que el fin de linea es 0D 0A (CR+LF), si se cambia por el estilo manejado en Linux, el problema persiste:

20 67 73 69 C4 0A

Incluso quitando todo el fin de línea el problema continua. Así que a este punto, leyendo un poco sobre UTF-8, entendí que el problema puede ser el siguiente:

Al tratar de leer el archivo, no sabe si esta en formato ASCII, UTF-8, ISO-88-59-15 (1 byte por carácter), pareciera que lo primero que asume es que es UTF8, y de razón, por que Ubuntu trae por defecto esta codificación, con la mala suerte que genera un fatal error cuando un archivo no está codificado realmente así, pues  como en el caso mostrado al tener C4 contiene los bits 110xxxxx que hace que espere un segundo byte en UTF-8, y como no existe ese byte, supongo que al tratar de acceder a la posición de memoria fuera de la memoria reservada ocurre el fallo.

Posibles modos de solución

  1. La mas simple, puede ser abrir el documento con otro programa y guardar el documento cambiando el formato de nueva linea (\n), por ejemplo si está en el formato Linux (LF), usar el formato  de Windows (CR+LF), o viceversa y cruzar los dedos.
  2. Agregar algún carácter al comienzo del documento, con esto las posiciones donde hay caracteres no ASCII cambian y podría ya no existir el error.
  3. Abrir el documento con otro programa, por ejemplo el notepad con el que viene Wine, copiar al portapeles el contenido, abrir un nuevo documento con gedit, pegar la información y guardar con el formato que comúnmente trabaje más.
  4. Usar otro editor de archivos de texto =(.

Posibles situaciones que generan el error

  1. Usar archivos que contienen caracteres especiales que no se han creado desde el inicio en el mismo directorio (traídos o copiados de algún lado diferente).
  2. Al editar un documento, abrir otros documentos que presentan el error, o que simplemente están en formatos de codificación diferente, es decir puede estar abierto un archivo en ISO-88-59-15, y luego se abre otro archivo con formato UTF-8, esto puede hacer que aparezca el bug, si algún carácter que no sea ASCII esta en una posición de memoria en particular.

Conclusión sobre el origen del mal

Mi hipótesis es que Gedit no gestiona bien el reconocimiento de diferentes formatos de codificación del texto, lo cual en ciertos casos provoca que trate de acceder a posiciones de memoria no reservadas para terminar de leer los caracteres. Me da la impresión que el tipo de formato de un documento en especial, siempre que se haya gestionado bien su formato, se guara tal información por aparte del archivo en si, por ello el mismo archivo con el error, puede en tales casos donde Gedit tiene un soporte del formato adecuado, abre el documento sin problemas, y por ejemplo al copiar ese mismo archivo a otro directorio, ya puede generar inconvenientes, por ello mismo una recomendación para evitar el error es trabajar con el documento sin cambiarlo de directorio, ni tampoco abrir otros documentos que estén en otro formato de codificación de caracteres.

lunes, 17 de octubre de 2016

Herramienta para agrupar textos semejantes

Tanto tiempo sin publicar nada, pero bueno, hoy les traigo una herramienta que realicé con googlescript para poder agrupar textos semejantes.

La base del algoritmo de comparación de textos está en el algoritmo de distancia de Levenshtein, al cual le hice algunos ajustes, el importante y a saber, la distancia ya no es un número entero, si no un valor normalizado de 0 a 1, donde 0 indica que la distancia es cero, y 1 que son totalmente diferentes. La distancia es el criterio para agrupar los textos parecidos que se hallan en una hoja cálculo, es excelente para procesar información que se recibe a través de formularios en google.

A continuación les dejo un video donde se explica su modo de uso, previo deben crear una copia del documento con los scripts de la herramienta.


Como bonus también está la herramienta para pasar información entre diferentes listas de información.

martes, 23 de agosto de 2011

Gnu Octave: Alternativa gratuita a Matlab






El programa al que se hace mención es una excelente alternativa de MATLAB, puesto que permite trabajar con una sintaxis casi idéntica de tal forma que muchas rutinas pueden ser compatibles entre los dos programas y lo más importante es que se puede adquirir de forma totalmente gratuita. Quizá para quien inicie con este programa Gnu Octave permite un sin numero de operaciones para el manejo especializado de vectores, con lo cual se puede hacer el manejo de gran variedad de información. Es posible trabajar toda la matemática de vectores de una manera sencilla, manejo de operaciones con números complejos, derivadas, integrales, raíces de polinomios; también es importante anotar que se pueden mostrar gráficas de ecuaciones en dos y tres dimensiones mediante otro programa que acompaña a Gnu Octave; además existen otras funciones especiales para el manejo de imágenes, y sonido.
Se puede decir que el programa en cuestión no es solo un programa de matemáticas, si no que se vale de estas para desarrollar un propio lenguaje con el cual se pueden solucionar variedad de problemas a nivel profesional.
En el presente texto solo se darán a conocer algunas nociones básicas.


Entrar y salir
Cuando ya se tiene instalado Octave, aparecerá un icono en el escritorio, se accede a este programa como a cualquier otro (dando doble clic sobre su icono). Cuando se abre el programa aparece la ventana de comandos en la cual es donde se procederá a trabajar, su aspecto es un tanto sencillo, sin ninguna barra de herramientas, u opción donde se pueda seleccionar con el cursor; que esto no sea intimidante, pues el programa en si ofrece grandes posibilidades de trabajo. A continuación se presentan algunos datos de la versión seguidos del prompt (aviso) característico (octave:1>), este indica la línea donde puede empezar a digitar comandos o funciones. Para salir del programa puede digitar quit o exit.

Operaciones elementales.
Las operaciones como sumas, restas… Se realizan de manera normal, por ejemplo:

octave:2> 3+5
ans = 8
octave:3> 8/2
ans = 4
octave:4> 5*4
ans = 20
octave:5> 45-5
ans = 40
octave:6> 2^3
ans = 8

Como se observa en el ejemplo, estas operaciones no toman ninguna dificultad en comprenderlas, además de los operadores que se usan (+,-,/,*,^).

Crear variables.
Las variables son posiciones de memoria a las cuales se les pueden asignar diferentes valores, para crear una variable basta con asignarle una letra o un nombre que debe empezar por un carácter alfabético y definirle o asignarle un valor, esto se lo realiza mediante el signo “=”. Es IMPORTANTE tener en cuenta que se reconocen como diferentes las variables con nombres en mayúscula o en minúscula, esto también es valido para los comados.

Ejemplos:
octave:6> a=256
a = 256
octave:7> b=548;
octave:8> c=5+6
c = 11
En los ejemplos se pueden observar las diferentes formas para asignar valores a una variable, ya sea directamente el valor o mediante una operación. También es importante notar que si no se desea ver el valor asignado o el resultado del comando, se finaliza con “;”.

Crear Matrices.
Para crea matrices se puede hacerlo digitando los elementos, los de la misma fila están separados por espacios o comas, mientras que las filas están separadas por pulsaciones intro o por caracteres punto y coma (;). Por ejemplo, el siguiente comando define una matriz A de dimensión (3×3):

octave:9> A=[1 8 -2;2,6,8
> 7 5 -3]
A =

1 8 -2
2 6 8
7 5 -3
Se puede apreciar las diferentes formas de introducir los diferentes elementos de la matriz, que bien pudo haberse realizado de una sola manera espaciando sus elementos o colocando comas, y para las filas solo “;” o intro.

Si se desea crear un vector de números consecutivos se procede con el siguiente formato:
= ::
octave:10> B= 0:2:10
B =

0 2 4 6 8 10

octave:11> A= 0:2:11
A =

0 2 4 6 8 10

Aritmética de matrices.
Octave permite bastantes operaciones que facilitan el manejo de datos a nivel de matrices, por ello solo se explicarán las más básicas.

Un grupo de operaciones que se pueden realizar son las que respectan matrices con escalar.

octave:1> A= [1 2 -4; 1 -1 4; 5 -4 7];
octave:2> A+1
ans =

2 3 -3
2 0 5
6 -3 8

octave:3> B = A+1;
octave:4> B-1
ans =

1 2 -4
1 -1 4
5 -4 7

octave:5> 2*A
ans =

2 4 -8
2 -2 8
10 -8 14

También se pueden realizar las operaciones elemento por elemento de cada matriz, esto es posible mientras las matrices sean de iguales dimensiones.

octave:8> A.*B
ans =

2 6 12
2 -0 20
30 12 56

octave:9> A./B
ans =

0.50000 0.66667 1.33333
0.50000 -Inf 0.80000
0.83333 1.33333 0.87500

octave:10> A.+B
ans =

3 5 -7
3 -1 9
11 -7 15

octave:11> A.-B
ans =

-1 -1 -1
-1 -1 -1
-1 -1 -1

Como se observa, estas operaciones tiene en común que se antepone un punto a la operación normal que sería entre escalares.
Para las operaciones con matrices se tiene la multiplicación, división:
octave:15> B*A
ans =

-10 13 -17
27 -16 27
43 -17 20

octave:16> A/B
ans =

0.744444 -0.477778 0.077778
-0.255556 0.522222 0.077778
-0.255556 -0.477778 1.077778

octave:17> A\B
ans =

1.48387 0.48387 0.48387
1.03226 2.03226 1.03226
0.38710 0.38710 1.38710

Funciones Elementales y Trascendentes
Gnu Octave posee funciones predefinidas que se representan por su nombre y se aplican a uno o varios argumentos. La sintaxis es: función (argum-1, argum-2, … argum-n) Obviamente, se puede asignar el resultado a una variable:
Variable =función
Variable =expresión

• Básicas: abs, sqrt, round, fix, floor, ceil, sign, rem, mod, gcd,
lcm
• Trigonométricas: sin, cos, tan, cot, sec, csc, asin, acos, atan,
acot, asec, acsc
• Hiperbólicas: sinh, cosh, tanh, coth, sech, csch, asinh, acosh,
atanh, acoth, asech, acsch, log (natural)
• Trascendentes: log10 (base 10), log2 (base 2), exp (potencias
de e), pow2 (potencias de 2)
• De argumento complejo: angle, real, imag, conj
Se puede usar la ayuda que brinda el mismo programa, que indica las funciones de los diferentes comandos solamente digitando help seguido del comando o función buscada.

Constantes Predeterminadas
Se definen internamente:
  •  pi: π = 3, 14159...
  •  i, j: √−1 (imaginario)
  •  Inf: ∞ (infinito)
  •  NaN: Not a Number (0/0)
  •  clock: hora actual
  • date: fecha actual
  •  eps: diferencia mas pequeña entre dos valores
  •  ans: variable de salida por defecto
Formatos de salida
Representan las distintas formas de exhibición por pantalla de los resultados.
  •  short: es el formato estándar. Muestra la parte entera y 4 dígitos decimales.
  •  long: Parte entera y 14 dígitos decimales.
  •  bank: Parte entera y 2 dígitos decimales
  •  rat: Formato de fracciones. Exhibe los resultados de las operaciones en la forma a/b.
  •  hex: Formato hexadecimal (0-9, A-F).
Los formatos short y long presentan una opción en notación científica: short
e y long e. Para trabajar estos formatos se usa el comando format .

Números Complejos
Octave define las constantes i o j como la unidad imaginaria √−1. Si se expresa un número complejo en su forma binómica como z = (a + bi), su conjugado es zconj = (a − bi) (definido con el comando conj (z)). Otros comandos utilizados en la operatoria con complejos son:
  • real(x): calcula la parte real de un número complejo x
  • imag(x): calcula la parte imaginaria del número complejo x
  • abs(x): calcula el modulo de un número complejo
  • angle(x): calcula el valor del ángulo entre −π y π que representa el argumento de un número complejo. Se aplica atan2(imag(x)/real(x)).

Otros comandos y funciones.
  • rand (,), (): genera matrices con números al azar.
  • tic;<>; toc: contabiliza el tiempo que tarda en ejecutar las operaciones que están definidas entre las dos palabras clave.
  • who: muestra las variables que están disponibles.
  • whos: igual a who solo que además indica el tamaño usado por las variables.
  • clear: borra todas las variables, si se especifica también se puede borrar una variable en especial.
  • clc: lleva el prompt al inicio de la pantalla, también se usa igual el comando home.


Graficar funciones.

Para graficar funciones se lo realiza mediante el uso de vectores, en donde se define el dominio de la función con intervalo que se desee evaluar (“resolución de la funcion”), y se usa el comando plot(,).

octave:60> x=0:0.1:10;
octave:61> y= 3*x+3;
octave:62> plot(x,y)




En el ejemplo se grafica f(x) = y = 3X + 3; evaluado cada 0.1 unidades, de cero a 10.
Para un polinomio en “x” f(x) = X 2 + 2X

octave:63> y= x.^2+2*x+3;
octave:64> plot(x,y)

Se deben tener en cuenta como se operan los vectores, para elevar al cuadrado se debe optar por “.^” porque es un error elevar un vector al cuadrado. También es posible realizar gráficos con coordenadas polares con el comando polar(<ángulo>, ).

Ejemplo:
Rosa de tres pétalos:
octave:26> angulo=0:pi/60:2*pi;
octave:27> radio=10*sin(3*angulo);
octave:28> polar(angulo,radio)

Existen varias opciones que permiten modificar el gráfico, algunas son:
  •   title: Pone titulo al grafico, se usa title(’TITULO’)
  •   xlabel: Pone una etiqueta al eje x, xlabel(‘DISTANCIA’)
  •   ylabel: Pone una etiqueta al eje y, ylabel(‘ALTURA’)

domingo, 9 de agosto de 2009

Producto de polinomios en la fx-7400G

Para muchos de los que poseemos la calculadora mencionada es bien conocido que las operaciones posibles son un tanto restringidas, pero si hacemos buen uso de las posibilidades que se ofrecen en su programación es posible obtener una gran gama de utilidades. A continuación se presenta un programa con el cual será de suma facilidad realizar el producto de dos polinomios de una forma sencilla y no con engorrosas operaciones que implica hacerlo sobre el papel y haciéndose muy común el error.

El modo de uso es el siguiente, primero solicita el polinomio A, este se debe ingresar a modo de lista especificando los coeficientes numéricos del polinomio.

Ejemplo:
3x+1 => se escribiría {3,1}, 3x^2+1 => {3 ,0 ,1}, es importante notar que cuando faltan coeficientes se los debe llenar con ceros.

Cuando solicita el polinomio B el formato a escribir es el mismo anterior, luego con un simple EXE el resultado se mostrara en el mismo formato de coeficientes del polinomio resultante.

El programa que llamen POLIP

= POLIP=

"A" ? &F List 1 &EXE //Solicita polinomio A
"B" ? &F List 2 &EXE // Solicita polinomio B
Dim List 1 &F M &EXE // Dimension polinomio A (M)
Dim List 2 &F N &EXE // Dimension polinomio B (N)
M+N-1 &F P&EXE //Dimension del polinomio resultante (P)
Seq(0C, C, 1, P, //Inicializa la lista 6 como lista auxiliar
1) &F List 6 &EXE //Donde los resultados se acumulan
For 0 &F I To (N //Recorrido para el polinomio B
-1) &EXE
For 0 &F J To (M //Recorrido para el polinomio A
-1) &EXE
List 6 [P-I-J] //Suma el resultado paracial al actual,
+List 1 [M-J] x //y guarda en la misma posicion
List 2 [N-I] &F
List 6 [P-I-J] &EXE
Next &EXE
Next &EXE
List 6 &EXE //muestra el resultado

Un ejemplo sencillo de producto de polinomios, (2X+3)(5X+1)= 10X^2+17X+3:

A?

{2, 3}

B?

{5, 1}

Ans

[10

17

3]

Es mas o menos lo que seria el resultado y su modo de uso. Una nota adicional es que tengan cuidado con los datos que tienen en las listas 1,2 y 6 puesto que estos son alterados por el programa, ya que este hace uso de dichas listas y los valores anteriores serian borrados. Espero haber sido claro y si surgen dudas miren las otras entradas del blog porque creo que por allí podria estar la respuesta.

viernes, 22 de agosto de 2008

CASIO FX-7400G PLUS: Programa MT SMXN

El siguiente programa permite solucionar sistemas de ecuaciones algebraicas de primer orden teóricamente para n variables, para ello se vale de la matriz aumentada del sistema y a la cual se le aplica la eliminación de Gauss Jordan. El programa ya ha sido probado debidamente, pero es de aclarar que el autor no se hace responsable por ningún daño o consecuencia que se derive del uso del programa. También es importante tener idea de cómo funciona el programa, para así no tener ningún inconveniente.

Para ingresar la matriz, se hace uso de la lista 1, se ingresa al modo LIST y se ingresan los valores consecutivamente de izquierda a derecha y en orden de filas descendente de la matriz aumentada del sistema, de tal forma que quedará todo en forma de una sola columna, luego se procede a ejecutar el programa desde el modo PRGM, al solicitar VARS se digita el numero de variables del sistema y entonces se debe esperar por algún tiempo dependiendo de la complejidad del cálculo y la respuesta se presentará como una lista. El programa hace uso de la lista 6, por ello si ha datos allí se borrarán y serán cambiados por las respuestas respectivas; también es de aclarar que usa muchas de las 26 variables (A, B, C…), y por ello sus valores almacenados serán borrados.

Un último detalle, el programa usa otro auxiliar llamado “MTAUX” ( si tienes alguna duda del lenguaje revisa Calculadora CASIO fx-7400G PLUS ) que es:
  • = MTAUX=
    Dim List 1 &F S &EXE
    If T=0 &EXE
    Then List 1 &EXE
    Seq(U,U,1,2S,1) &F List 1 &EXE
    For 1 &F U To 2S &EXE
    List Ans [(U-1) Rmdr S+1] &F List 1 [U] &EXE
    Next &EXE
    Else If T=-1 &EXE
    Then Seq(List 1 [U+ S/2],U,1,S/2,1) &EXE
    List Ans &F List 1 &EXE
    Else If T>0 &EXE
    Then For 1 &F U To Z &EXE
    List Ans[U] &F List 1[Z(T-1 )+U] &EXE
    Next &EXE
    IfEnd &EXE

Ahora está el programa principal:

  • = MT SMXN =
    “VARS”? &F Y &EXE
    Y+1 &F Z &EXE
    Dim List 1 ¡= YxZ => Stop &EXE
    0 &F T &EXE
    Prog “MTAUX” &EXE
    For 1 &F V To Y &EXE
    List 1 [(V-1)Z+V] &F X &EXE
    X = 0 => Stop &EXE
    Seq(List 1[(V-1)Z+U],U,1,Z,1) &EXE
    List Ans &D X &F List 6 &EXE
    For 1 &F W To Y &EXE
    W &F T &EXE
    If W = V &EXE
    Then List 6 &EXE
    Prog “MTAUX” &EXE
    Else Seq( List 1 [(w-1)Z+U],U,1,Z,1) &EXE
    List Ans – List 1[(W-1)Z + V] x List 6 &EXE
    Prog “MTAUX” &EXE
    IfEnd &EXE
    Next &EXE
    Next &EXE
    Seq (List 1 [ZU],U,1,Y,1) &F List 6 &EXE
    -1 &F T &EXE
    Prog “MTAUX” &EXE
    List 6 &EXE

Espero lo disfruten y no tengan inconvenientes.

lunes, 11 de agosto de 2008

CASIO FX-7400G PLUS: Programas

A continuación se presenta el codigo algunos programas, si no entiendes algo o no sabes como interpretar el codigo dirigete a Calculador CASIO FX-7400G PLUS.

M INV2:
Programa para obtener la matriz inversa de una matriz 2x2, el cual pide uno a uno cada valor de la matriz indicando cada posición (fila, columna). Se debe tener en cuenta que x indica multiplicador por y X como variable, el resultado final se muestra como una lista de la cual se puede ver cada valor usando las “flechas” de REPLAY.
  • “11”? &F A &EXE
    “12”? &F B &EXE
    “21”? &F C &EXE
    “22”? &F D &EXE
    1/(AD-CD) &F X &A
    “X”&A
    {D,-B,-C, A} x X &EXE
    Stop &EXE

M MLT2:
Programa para obtener la multiplicación de dos matrices 2x2, igual que el anterior solicita los valores de la matriz A y la matriz B:

  • “A11”? &F A &EXE
    “A12”? &F B &EXE
    “A21”? &F C &EXE
    “A22”? &F D &EXE
    “B11”? &F E &EXE
    “B12”? &F F&EXE
    “B21”? &F G &EXE
    “B22”? &F H &EXE
    {AE+BG,AF+BH,CE+DG,CF+DH} &EXE
    Stop &EXE

jueves, 7 de agosto de 2008

Calculadora CASIO fX-7400G PLUS.


Esta calculadora aunque no posee muchas de las funciones que quisiéramos, permite que podamos programar muchas de ellas en la mediada en que se conozca el lenguaje que usa. A continuación presento el set de instrucciones que es posible usar de la forma en que está organizado dentro de la calculadora.
Para desplazarse en el menú asignado a las teclas de función se usa >, para entrar EXE, y para salir de un submenú QUIT.

En la sección de programación (6-PRGM) es posible editar un programa que ya está elaborado (F2-EDIT) o crear uno nuevo (F3-NEW) digitando el nombre y luego EXE.
En un comienzo aparecen los siguientes comandos en grupos de a 3:



TOP
BTM
MENU
'
''
~
*
/
#



Para entrar al menú de programación se usa SHIFT+VARS, y se tendrán las opciones siguientes:


COM
CTL
JUM
?
A
CLR
DISP
REL
I/0
:





Las opciones de Com son:

If
Then
Else
I-end
For
to
Step
Next
While
Wend
Do
Lpw

Las opciones de CTL:

Prog
Rtrn
Brk
Stop



Opciones de JUMP :

Lbl
Goto
=>
Isz
Dsz


Opciones de CLR :

Text
GRph
List



Opciones de Disp:



Stat
Grph
Tabl



Opciones REL:



=
Diferente
< >
<= >=



Opciones I/O:



Send
Recv


Vale aclarar que algunos de los anteriores comandos no aparecen exactamente como se muestran; conociendo donde se ubica cada cosa ya es posible empezar a crear programas, es posible empezar copiando algunos programas para familiarizarse con los comandos. Para continuar valdrá de mucho hacer algunas convenciones porque no es posible redactar el código fuente tal cual aparece en la calculadora:

  • &A: salida de texto, originalmente es un triángulo rectángulo.
  • !=: relacional diferente.
  • >=: relacional mayor o igual.
  • <=: relacional menor o igual.
  • =>: Salto por condición entonces.
  • &EXE: la función de dicha tecla.
  • &R: raíz cuadrada.
  • &D: simbolo division
  • &P: potencia, x cuadrado sería X&P2.
  • &F: flecha de asignación a una variable.
  • &PI: símbolo pi.
  • &EXP: notación científica con potencias de 10.
  • /: símbolo para indicar fracción (Tecla - a b/c).
  • x: equis minúscula, simbolo multiplicación.
  • A,B,C...: letras mayúsculas, variables de la calculadora.
  • //: comentario de una linea (No es opcion de la calculadora).
  • /* : apertura comentario multilinea.
  • */ : cierre comentario multilinea.

Una función útil que la calculadora no posee es hallar el determinante a una matriz 3x3, lo denominé DT3 y este es el código:

List1[1]List1[5]List1[9]+List1[4]List1[8]List1[3]+ List1[7]List1[2]List1[6]-List1[7]List1[5]List1[3]-List1[1]List1[8]List1[6]-List1[4]List1[2]List1[9] &EXE
Stop&EXE.

Para ejecutar el programa primero se deben ingresar los valores de la matriz en la lista uno, ingresando a LIST desde el menú principal; los primeros tres números son la primera fila, los tres siguientes son la segunda fila, y los tres últimos son la tercera fila. Es importante tener en cuenta el orden de los números que se ingresan, por ejemplo si se escribe 1, 3, 7, -2, 3, 1, 3, 5, 1 , para ejecutar el programa se ingresa a PRGM donde aparece el listado de programas, se selecciona DT3 y EXE, entonces en pantalla aparece el resultado que para el ejemplo será -120. La matriz que corresponde al ejemplo anterior es:



1

3

7
-2
3
1
3

5
1


Si deseas ver más programas dirigite a CASIO FX-7400G PLUS: Programas

domingo, 3 de agosto de 2008

Programacion de juegos en Simple J

Muy bien, como lo prometido es deuda, aquí inicio una nueva entrada acer de la programación en simple j.
Para los nuevos, simple j es un lenguaje diseñado para aquellos que se inician en la programación, por ello posee una estructura sencilla y a la vez lo suficientemente poderosa como para crear un juego. Su estructura se basa en la programacion de un chip Emulado, el IAVC, de tal forma que existen comandos para controlar sus registros. Los registros incluyen graficos de dos tipos, tiles y sprites; produccion de sonido bajo formas de ondas y la edicion de algunas de sus propiedades... en fin son muchas las posibilidades con las cuales se puede aprender un sin fin de cosas en el ambito de la programación.

La pagina oficial en español es Crea tus propios videojuegos. Espero poder ayudar

Libros

Aquí inicio una lista de los libros a los que hago referencia en otros comentarios.

Matemáticas:
  • [PR1] Protter, Morrey. Cálculo con Geometría analítica. Fondo Educativo Interamericano, Tercera Edición; 1980.