Anuncio

Colapsar
1 de 2 < >

Guí­as importantes para los nuevos usuarios


Bueno acá les dejo las guias que deberían leer antes de hacer cualquier tipo de pregunta, y es muy recomendable que además las complementen con el manual de la calculadora.

Uso del foro




Reglas generales de utilización del foro

Aunque muchos se saltan estas reglas.. (sobre todos los que tratan de vender calculadoras o promocionar algún servicio) Todos los post que incurran en alguna falta al reglamento serán advertidos o borrados del foro.


Nadie está obligado a contestar todos los posts, aquí no hay personas que les paguen por responder.. así que si tu nuevo post no obtuvo respuestas, o no te diste a explicar bien.. o de plano los usuarios que estamos aquí desconocemos del tema, asi que no entren exigiendo respuestas.

- Para las personas que publican su post varias veces en diferentes partes.. con una sola vez, lo leemos
perfectamente.. los post duplicados serán borrados del foro, evitense la molestia.

-
Cuando creen un nuevo post, pongan títulos lo más
explicativos y breves posibles, títulos como: ayuda urgente!! - necesito programa!! - no se que hacer!! esos post
serán menos identificables y perjudican la clasificación de posts en el
foro.

- Sean lo más objetivo posible cuando detallen
su problema en un nuevo post, expliquen todo los detalles, que calcualdora poseen?
sistema operativo? parches y kernels instalados? memoria libre? que pasos
realizaron exactamente? y si pueden poner imágenes del problema en si, mucho
mejor.

- Por favor, solo usen los mensajes privados,
cuando no quieren que se enteren los demas de algun tema, pero
NO hagan preguntas sobre calculadoras. Las preguntas se
responden unicamente en el foro, no tengan miedo o pena por
preguntar.

- FAQ sobre el uso del foro


- ¿Como
subo fotos al foro?


- ¿Como
suscribirse a un tema?
Esta herramienta nos permite guardar post que
nos interesa, para en un futuro volver acceder a ellos con facilidad.

-
¿Como puedo perzonalizar el avatar?

- Antes de
realizar cualquier pregunta en el foro, primero usen el Buscador del Foro, para
consultar si su pregunta no ha sido hecha por otro usuario, con ésto evitamos
repetir los mismo temas y mantenemos el foro mas organizado, en
caso de ser un tema repetido será advertido y
borrado del foro.

Para realizar búsquedas en el foro,
aquí tienen un ejemplo:



Lean éste post, si
desean más información sobre como realizar
búsquedas y sobre la distribución del foro.



Uso de la
calculadora
:


- Guia IMPORTANTISIMA! "solucion de problemas
tipicos
"
(No pregunten antes de no leer esta guia
por que lo explica casi todo en relación a los problemas), los temas de los
que habla son: los tipicos errores que saltan cuando uno empieza a usar
la calculadora, como archivar variables, uso del var-link, como mandar archivos
de la PC a la calculadora, etc.

-
Preguntas frecuentes sobre la calculadora

- Guia
de como correr un programa en la calculadora


- Guía para
enviar programas a la calculadora
(Animación)

- Guia importante sobre los programas hechos en
ensamblador (ASM) y como ejecutarlos con cuidado


- Guia sobre el uso del hibview, programa para abrir TXT en
la calculadora, y la instalación del Preos, programa importantísimo que
lo tengan instalado


- Guia de como solucionar posibles errores de conexión entre
nuestras calculadoras y la PC.


- ¿Como
Reseteo la calculadora?



Programas en nuestras PCs:


-Daisuke-Edit:Software de edición/creación de
TI-BASIC


-Guia que trata sobre la instalación de un emulador (TI-Emu)
en nuestras PC


- Guia sobre como crear imágenes de alta calidad en nuestras calculadoras (Por el momento
funciona con la TI89/Titanium, con la V200 supuestamente no)

- Guia acerca del Wordrider, programa que sirve para crear
textos en nuestras PCs, ideal para usar con el hibview, y el uview


-
Guia sobre como usar el "TI-Reader Converter": Guia 1, Guia
2




Programación:


- Lo
que cualquier programador de TI-Basic necesita
(Guias y
manuales para programar en todos los niveles)

- Pequeña guia introductoria para empezar a programar en TI-Basic (Muy util para el que no sabe nada de nada)

- Guia sobre el uso del Tigcc para programar en C .




Recomendaciones para la calculadora:

- Leanse el
manual,
no sean vagos: Link en español

- Si
desean bajar alguna aplicacion (APP) de Texas o bajar el ultimo OS para su
calculadora visiten el siguiente enlace.

- Siempre usen su calculadora en
INGLES.. esto se debe a que la mayoría (por no decir todos) de los
programas están escritos en ingles, y como los comandos difieren entre español y
el ingles.. pues los programas nunca funcionaran mientras la calc esté en
español.

- Instalen el HW3Patch (solo en TI89 Titanium) el cual es necesario para
algunos programas en ASM.

- Instalen el PreOS, este es un Kernel
necesario para hacer correr algunos programas en ASM y también proteger la
calculadora ante algún error grave.. evitando que se trabe.
(Importante
: si tienen TI89 Titanium deben instalar primero el
HW3Patch antes que el PreOS)

- Usen el Equation writer o el Hail para
ingresar los datos, lo harán mas rápido.


-
EQW (Equation Writer) TI89 y
Titanium

- TI92 y V200

-
Hail



- Todos los programas que quieran instalar en la
calculadora (sobretodo los del tipo ASM), pruebenlos antes en el emulador, para evitar dañar la calculadora si el
programa llegara a fallar o trabar la calculadora.

- Saquen las
pilas si no van a usar la calculadora por mucho tiempo.

- Por
ultimo, si quieren algún programa, además de buscarlo en el foro, vayan a
la pagina mas importante de Texas, donde se encuentran casi todos los programas
existentes "
Ticalc.org".



Nota:
Si piensan que falta alguna guia en este
post o cualquier mejora, por favor.. haganlo saber en éste tema.


Guia creada por cosmefulanito04 y
actualizada por izerw
25/07/07

2 de 2 < >

Guía para enviar programas a la calculadora







Gracias a dondiego por la animación
Ver más
Ver menos

Ejemplos de Programacion.

Colapsar
X
  • Filtrar
  • Tiempo
  • Mostrar
Limpiar Todo
nuevos mensajes

  • Ejemplos de Programacion.

    Bueno, para q no se pierdan en la parte principal del foro, dejo aca los ejemplo q puse.

    Links de los mensajes originales:

    Problema nº 1

    Problema nº 2

    Problema nº 3

    Problema nº 4

    Yo creo q con eso pueden aprender a programar, pero si ven q les cuesta dar el 1er paso, se podria realizar una guia introductoria mas completa de la q hay.
    Editado por última vez por cosmefulanito04; http://www.calculadoras.cl/foro/member/618-cosmefulanito04 en 19/01/08, 07:51:47.
    Antecedentes
    Guia para usuarios nuevos (Leanla antes de postear)

    La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

  • #2
    Problema nº1

    Bue como habia comentado antes, estaria bueno plantear un problema y que los usuarios q estan aprendiendo a programar puedan resolverlo. La idea es plantear problemas basicos, pero q al mismo tiempo les sirva a los programadores como manejar ciertos comandos o cierto tipo de variables.

    Antes de empezar, voy a considerar q los usuarios saben:

    - Ingresar datos, con input o ventana de dialogos.
    - Imprimir datos, con pause o disp.
    - Idea basica de como funciona el for, if, etc y todo esos comandos.

    En caso de no saber como hacer esto, les recomiendo leer esto:

    TI-BASIC: Documentación para programadores; hecha por Unike.

    Guia rapida de principiantes (Con esta empece yo); hecha por Jinn.

    - Problema planteado (manejo de matrices y listas):

    Se desea obtener el area y el perimetro de "n" rectangulos, mostrar el rectangulo de mayor area, indicando de q rectangulo se trata y por ultimo darle la opcion al usuario de elegir que area y perimetro ver.
    (area=largo*ancho; perimetro=2*largo+2*ancho)

    Se pide q:

    - Usen solo variables locales.
    - En caso de tocar "esc" en una ventana, el usuario podra salir.
    - Trabajar con la calculadora en ingles.
    - Teclado en modo numerico.
    - No mas de 6 variables.
    - Poder repetir la operacion al finalizar una.
    - Peso maximo de 5 kbytes (y es mucho para lo q pido).

    Se podra:

    - Trabajar con input o con ventanas dialog.
    - Imprimir respuestas con disp/pause o con ventanas dialog.
    - No habra necesidad de verificar si hay datos en las ventanas, pero si desean hacer la verificacion, haganla.

    Ejemplo de lo q kiero:



    Yo use 5 variables locales y el peso del programa fue de 1103 bytes.

    Pistas, algunos comandos q use, tal vez les sirva:

    - Augment
    - mat>list
    - traspuesta ( ,a ver si saben para q este)
    - Manual a mano

    La idea de este problema es enfocarse exclusivamente en la programacion y no en la parte matematica, y de esta forma el programador pueda aprender a manejarse con matrices y listas, variables muy importantes para la mayoria de los programas q realicemos en el futuro.
    Antecedentes
    Guia para usuarios nuevos (Leanla antes de postear)

    La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

    Comentario


    • #3
      Solucion - Problema nº 1

      Diagrama de Flujo:



      Aca les paso la solucion:

      Explicacion de las etapas:

      1- Etapa de ingreso:

      Código:
      ...
        "1"->num  
        dialog
          title "Cantidad de Rectangulos"
          text ""
          request "Nº de rectangulos",num,0
          text ""
        enddlog // Ventana para ingresar la cantidad de rectangulos.
        if ok=0
          exit
        
        expr(num)->num
        
        for cont,1,num,1 // For para los "n" rectangulos, va desde 1 hasta num (num= cant. de rectangulos)
          "0"->aux:"0"->aux2
          dialog 
            title "Rectangulo "&string(cont)
            text ""
            request "Largo",aux,0
            text ""
            request "Ancho",aux2
            text ""
          enddlog // Ventana para ingresar el Largo y el Ancho de los rectangulos
          if ok=0
            exit
          expr(aux)->aux:expr(aux2)->aux2
          
          if cont=1 then // Pregunto si es el 1er ingreso
            ["Rectangulo "&string(cont),aux*aux2,2*aux+2*aux2]->rta // En el 1er ingreso, creo la Matriz a donde voy a guardar los datos.
          else
            augment(rta;["Rectangulo "&string(cont),aux*aux2,2*aux+2*aux2])->rta // En caso de no ser el 1er ingreso, voy agregando los datos en la matriz creada.
          endif  
            
        endfor
      ....
      Si ponemos la lupa sobre la etapa, esta se veria asi:



      2- Etapa de busqueda del mayor area:

      Código:
      ...
        rta^T->rta  // Realizo la traspuesta, para girar completamente la matriz.
        mat>list(rta[1])->aux // Paso la fila 1 de la matriz a una lista, esta fila tiene el nº del rectangulos.
        mat->list(rta[2])->aux2 // Paso la fila 2 de la matriz a otra lista, esta fila tiene las areas.
        sortd aux2,aux // Ordeno de mayor a menor ambas listas, en funcion de la lista de las areas.
        
        clrio
        disp "Mayor area:",aux[1],"Area: "&string(aux2[1]) // Imprimo la respuesta, mostrando el 1er elemento de las 2 listas, osea el mayor area.
        pause
      ...
      La etapa se veria asi:



      3- Ultima etapa, imprimir resultados:

      Código:
      ...
      mat>list(rta[1])->aux // Paso la fila 1 de la matriz a una lista, la cual contiene los numeros de rectangulos.
        loop
          1->num
          dialog 
            title "Respuesta"
            text ""
            dropdown "Rectangulo",aux,num
            text ""
          enddlog // Ventana para elegir el rectangulo
          if ok=0
            exit
          clrio
          disp aux[num],"Area: "&string(rta[2,num]),"Perimetro: "&string(rta[3,num])
          pause  
        endloop
      ...
      La solucion cumple con lo pedido, ya q el objetivo era aprender a usar matrices y listas.

      Igualmente este ejercicio seria conveniente hacerlo enteramente usando listas, ya q de esa forma se evita tener q transformar y girar matrices, y se obtiene mayor velocidad. Mañana les subo la solucion usando listas.

      Aca les dejo el programa para q lo vean.

      Solucion alternativa, hecha por el usuario Daz:

      http://www.calculadoras.cl/foro/show...1&postcount=46
      Archivos Adjuntos
      Editado por última vez por cosmefulanito04; http://www.calculadoras.cl/foro/member/618-cosmefulanito04 en 10/10/08, 15:55:40.
      Antecedentes
      Guia para usuarios nuevos (Leanla antes de postear)

      La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

      Comentario


      • #4
        Problema nº 2

        Siguiendo con el problema planteado en este post , ahora se plantea otro:

        Aca el amigo acg82 nos propone un interesante problema, donde incluye nuevos desafios q pueden ser interesante para algunos, como graficar puntos y mostrar "n" resultados a la vez.

        Resumen del problema:

        Se desea obtener los "n" resultado de la sucesion de Fibonacci, imprimirlos en pantalla y por ultimo graficar los "n" puntos de la sucesion.

        Sucesion de fibonacci: 0,1,1,2,3,5,8,13,21,.... etc

        Salvo Suc(0)=0, y Suc(1)=1, el resto de la sucesiones se obtienen de hacer esto:

        Suc(n)=Suc(n-2)+Suc(n-1) osea Suc(2)=Suc(0)+Suc(1)=0+1=1 (en n=2 la sucesion vale 1)

        Mas detalles de la sucesion (Wikipedia)

        Se pide q:

        - Usen solo variables locales, salvo las 2 listas usadas en Newplot.
        - En caso de tocar "esc" en una ventana, el usuario podra salir.
        - Trabajar con la calculadora en ingles.
        - Teclado en modo numerico.
        - No mas de 8 variables.
        - Poder repetir la operacion al finalizar una.
        - Peso maximo de 3 kbytes (y es mucho para lo q pido).

        Se podra:

        - Trabajar con input o con ventanas dialog.
        - Imprimir respuestas con disp/pause o con ventanas dialog.
        - No habra necesidad de verificar si hay datos en las ventanas, pero si desean hacer la verificacion, haganla.

        Ejemplo de lo q pido:



        Comandos usados:

        - Seq
        - NewPlot (para este recomiendo usar dos listas como variables globales y luego borrarlas)
        - ZoomIn, Zoomout, ZoomDec, ZoomFit (combinandolo con un dropdown)

        - Proposito, aprender a encarar de manera correcta un ciclo for/while/etc para fines matematicos, poder graficar puntos aislados y poder manejar los distintos zooms.
        Antecedentes
        Guia para usuarios nuevos (Leanla antes de postear)

        La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

        Comentario


        • #5
          Solucion - Problema nº 2

          Diagrama de Flujo:



          Codigo por partes:

          Variables declaradas y eliminacion del contenido de la variables globales necesarias

          Código:
          Local num,aux,aux2,aux3
          DelVar main\listx,main\listy
          Ingreso del orden y resultado de la sucesion

          Código:
          ...
            "0"->num
            Dialog
              Title "Orden de la serie"
              Text ""
              Request "Ingrese un numero",num,0
              Text ""
              Text ""
            EndDlog
            If ok=0
              Exit
            expr(num)->num // Ingreso del orden de la sucesion, uniko dato q ingresa el usuario
            
            {"n=0"}->aux
            {0}->aux3 // Creo 2 listas, la 1era contiene el orden de la sucecion y la segunda su resultado, la serie en n=0 vale 0
            
            If num!=0 Then 
              augment(aux,{"n=1"})->aux
              augment(aux3,{1})->aux3
            EndIf // En caso de ingresar un orden mayor a 0, se agrega el resultado del orden n=1 q vale 1, los 2 primeros ordenes es recomendable ingresarlo uno, ya q no tienen ningun algoritmo raro
            
            For aux2,2,num,1
              augment(aux,{"n="&string(aux2)})->aux
              augment(aux3,{aux3[aux2-1]+aux3[aux2]})->aux3
            EndFor // A partir del algoritmo dado en el 1er post, se van agregando los ordenes y sus respectivos resultados, todo a partir del orden 2
            ClrIO
            Pause {aux,aux3}^t // Traspuesta de la matriz formada con las listas para luego imprimir el resultado obtenido
          ...
          Aca empieza la etapa de graficar los puntos obtenidos

          Código:
          ...
            seq(aux2,aux2,0,Dim(aux)-1)->aux2 // Este comando me permite basicamente crear una lista de este tipo {1,2,3,4,5,6,7,....,n} hasta el orden ingresado, esta lista me servira para ubicar los puntos obtenidos en el eje de las absisas "X"
            
            Dialog
              Title "Opcion"
              Text ""
              Text "¿Desea graficar los pts?"
              Text ""
            EndDlog 
            If ok=1 Then // Pregunto si se desea graficar
              FnOff
              PlotsOff  // Destildo todas las funciones para graficar en el Y=editor, como tb los posibles plots (q es lo q vamos hacer, un plot)
              aux2->main\listx // Guardo en la variable global, la listas de las absisas (la creada con seq).
              aux3->main\listy // Guardo en la variable global, la listas de los resultados obtenidos (osea los pt del eje de ordenadas "Y").
              NewPlot 1,1,main\listx,main\listy,,,,4 // Funcion q me permite definir un plot en el Y=editor
              
              {"ZoomIn","ZoomOut","ZoomDec","ZoomTrig","ZoomSqr","ZoomFit"}->aux2  // Creo una lista con los Zooms mas utilizados 
              Loop
                1->aux
                Dialog
                  Title "Tipo de Zoom"
                  Text "      Elija el Zoom"
                  Text ""
                  DropDown "Tipo de Zoom",aux2,aux
                  Text ""
                EndDlog // Ventana para elegir los Zooms, usando la lista creada antes
               
                expr(aux2[aux]) // Ejecuto el zoom elegido, pasandolo de String a un comando reconocible (Por eso el nombre de los Zooms)
                
                  
                Pause //Importante este pause, para poder ver el geafico.
                Dialog
                  Title ""
                  Text ""
                  text "¿Desea cambiar el Zoom?"
                  Text ""
                EndDlog
                If ok=0
                  Exit // Se vuelve a graficar tantas veces sea necesario hasta tocar "esc" en esta ventana.
            
              EndLoop
            EndIf
            
            Dialog
              Title "Opcion"
              Text ""
              Text "¿Desea repetir el calculo?"
              Text ""
            EndDlog
            If ok=0
              Exit
          ...
          Por ultimo se borran las variables globales, para q no haya valores basura

          Código:
          ...
          DelVar main\listx,main\listy
          ...
          Como veran se uso lista en vez de matrices, lo q me genero un par de variables mas, pero mejore la velocidad del programa. Abajo les dejo el programa terminado, si alguien se anima a mejorarlo q lo haga, asi aprendemos todos.

          Solucion alternativa, hecha por el usuario Daz:


          http://www.calculadoras.cl/foro/show...5&postcount=10
          Archivos Adjuntos
          Editado por última vez por cosmefulanito04; http://www.calculadoras.cl/foro/member/618-cosmefulanito04 en 10/10/08, 15:57:38.
          Antecedentes
          Guia para usuarios nuevos (Leanla antes de postear)

          La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

          Comentario


          • #6
            Problema nº 3

            Muchachos aca les dejo el problema mas complicado q les puedo plantear, el q pueda resolver esto, ya esta hecho . Tengan en cuenta q muchas cosas son conceptos anteriores de los problemas 2 y 1 .

            Problema:


            Se pide ingresar "n" funciones de 1 variable, la cual puede ser cualquiera (al menos 2 funciones debe ingresarse), un punto culquiera a evaluar, luego poder elegir 2 funciones y calcular punto/s de interseccion entre las 2 funciones, graficar ambas funciones y por ultimo dar la sumatoria de las funciones en el punto a evaluar (ja, esta lindo el problema).


            Nota: la interseccion de 2 funciones se calcula a partir de un sistema de 2 ecuaciones con 2 incognitas, recomiendo usar el solve asi:

            solve(vard=func1 and vard=func2,{vari,vard}) , teniendo en cuenta como funciona el solve (explicacion abajo).

            Ayuda de como obtener la sumatoria de las funciones en el punto a evaluar:

            http://www.calculadoras.cl/foro/show...4357#post24357

            Se pide q:

            - Usen solo variables locales.
            - En caso de tocar "esc" en una ventana, el usuario podra salir.
            - Trabajar con la calculadora en ingles.
            - Teclado en modo numerico.
            - No mas de 12 variables.
            - Poder repetir la operacion al finalizar una.
            - Peso maximo de 5 kbytes.
            - Verificar q se ingresen al menos 2 funciones y q no se elijan las mismas funciones.
            - En lo posible tratar de evitar posibles errores de ingreso (realmente yo no creo mucho en las verificaciones, pero esta bueno q aprendan hacerlas igual)
            - Usen y98(x) e y99(x) y luego borrenlas.

            Se podra:

            - Trabajar con input o con ventanas dialog.
            - Imprimir respuestas con disp/pause o con ventanas dialog.
            - No habra necesidad de verificar si hay datos en las ventanas, pero si desean hacer la verificacion, haganla.

            Ejemplo de lo q pido:



            - Propositos, aprender a usar los strings pudiendo manejar codigos dinamicos, poder graficar y por ultimo realizar una operacion al mismo tiempo q se van tomando los datos.

            Abajo les dejo un resumen teorico basico de como funciona los strings.

            Con esto ya estan casi listos, el resto de los problemas ya son mucho mas faciles comparado a este.
            Antecedentes
            Guia para usuarios nuevos (Leanla antes de postear)

            La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

            Comentario


            • #7
              Concepto de String - Problema nº 3

              Uso de String

              Antes q nada hagamos un repaso rapido de como operar con los strings:

              Código:
              ...
              "Hola" // Esto es un string y siempre esta entre comillas, tiene dimension 4 (si, se puede usar dim para ver su dimension, igual q una lista)
              ...
              Código:
              "Hola"&" yo soy pepito"-->aux // El & me permite pegar strings, algo muy util
              
              disp aux // Se vera "Hola yo soy pepito" y sin comillas se vera, por usar el comando disp el cual requiere de un string.
              Otra operacion importante:
              Código:
              ...
              (x+4)/2-->aux
              string(aux)-->aux // String(variable) convierte la expresion en un string, es decir aux= "(x+4)/2"
              disp "f(x)="&aux // Vemos f(x)=(x+4)/2, tal cual, no en pretty print sino en string
              ...
              Esas son las operaciones basicas del string, pero estas operaciones son importante saber usarlas.

              Otra cosa importante es acordarse del tipo de dato q recibe una ventana:

              Código:
              ...
              dialog
                title "Prueba"
                text ""
                request "Dato",data
                text "" 
              enddlog
              
              disp data // Veremos q data sera un string, por eso muchas veces se usa expr(data) despues de la ventana, ya q el dato recibido por request siempre es un string.
              ...
              Ese es un resumen basico de como operar con los strings, igual es recomendable q lean el manual de la calculadora y el manual de unike para ampliar mas el tema.


              Ahora, para q me sirve usar strings ademas de mostrar resultados?

              El uso de string es usado en ciertas ocasiones cuando queremos utilizar ciertos comandos de la calculadora y no podemos hacerlo de manera convencial, para no dar mas vuelta voy a poner ejemplos.

              Supongamos q en nuestro programa queremos usar el comando solve para resolver un sistema de ecuacion de 2x2, y sabemos q las variables de las ecuaciones siempre son "X" e "Y", entonces normalmente hariamos esto:

              Código:
              local ecu1,ecu2
              ....
              "0"-->ecu1:"0"-->ecu2
              dialog
                title "Ingreso de Ecuaciones"
                text ""
                request "Ecuacion 1",ecu1,0
                text ""
                request "Ecuacion 2",ecu2
              enddlog
              if ok=0
                return
              
              clrio
              disp "Solucion:",""
              pause solve(expr(ecu1) and expr(ecu2),{x,y})
              ...
              Pero si nosotros quisieramos hacer el mismo programa, pero para cualkier variable que ingrese el usuario, ese comando asi como lo usamos no serviria, por mas q hagamos esto:
              Código:
              ....
              Var. ingresada por usuario-->x
              Var. ingresada por usuario-->y
              solve(expr(ecu1) and expr(ecu),{x,y}) // Esto esta mal
              ....
              El problema es q el comando solve reconoce como a X e Y las variables de la ecuacion, y no reconoce el contenido de X e Y, y si a su vez estas variables tienen algun contenido, el comando trula, es decir q tira un error ("Argument must be a Boolean expression or integer"; osea todo mal )

              Pero existe una forma de enganiar al comando y es usando strings, este metodo nos permite generar un codigo dinamico (es decir q el compilador del ti-basic con un mismo programa, puede llegar a ver muchos codigos distintos a partir del ingreso del usuario) y ese codigo dinamico se hace a partir de un string, ejemplos basicos:

              Código:
              expr("pause 4") // Vemos q se ejecuta el comando pause, y muestra el numero 4
              Ahora trabajemos con variables:

              Código:
              ....
              (x+4)/2-->aux
              expr("pause f(x)="&string(aux)) // Vemos q se ejecuta el comando solve y nos muestra f(x)=(x+4)/2, pero en Pretty print, ya q ti-basic lo reconoce como el ingreso de una expresion
              ....
              Ahora volviendo al tema del solve, teniendo una idea de lo explicado, para enganiar al compilador se deberia hacer esto:
              Código:
              ...
              local ecu1,ecu2,aux,aux2
              
              "0"-->ecu1:"0"-->ecu2
              dialog
                title "Ingreso de Ecuaciones"
                text ""
                request "Ecuacion 1",ecu1,0
                text ""
                request "Ecuacion 2",ecu2
                text ""
                request "Variable 1",aux
                text ""
                request "Variable 1",aux2
                text ""
              enddlog  // Acuerdense q request toma strings
              if ok=0
                return
               
              clrio
              disp "Solucion:",""
              pause expr("solve("&ecu1&" and "&ecu2&",{"&aux&","&aux2&"})")  // Todo lo q esta en rojo es un string 
              ...
              Si lo prueban, van a ver q funciona, pero q interpreta Ti-basic? el comando solve como si hubiese sido escrito asi:

              solve(ecuacion1 and ecuacion2,{variable1,variable2})

              En otras palabras pudimos modificar el codigo segun el ingreso del usuario, lo cual es llamado codigo dinamico.

              Con este pekenio ejemplo ya podemos tener una idea de como trabajar con strings y cuales son sus ventajas. Ahora en el otro mensaje vamos a ver como podemos graficar usando strings.
              Antecedentes
              Guia para usuarios nuevos (Leanla antes de postear)

              La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

              Comentario


              • #8
                Graficar usando Strings - Problema nº 3

                Graficar usando strings


                Tal vez no lo notaron, pero si uno desea graficar una funcion y luego poder usar los distintos zooms, si o si tiene q caer en define y1(x)=mi funcion de esa forma definimos en y1(x) a nuestra funcion.

                Pero volvendo al caso anterior del solve, q pasa si nosotros queres definir esa funcion dentro del programa, se puede?

                Código:
                ...
                dialog
                  title "FUNCION"
                  text ""
                  request "Funcion",func,0
                  text ""
                enddlog
                ....
                fnoff
                plotsoff // Acuerdense, siempre destildamos los graficos ingresados anteriormente
                
                define y1(x)=expr(func) // Kuak!! error :)
                ....
                Nuevamente nos tira un error similar al anterior, y nuevamente usamos la misma solucion:

                Código:
                ...
                dialog
                  title "FUNCION"
                  text ""
                  request "Funcion",func,0
                  text ""
                enddlog
                ....
                fnoff
                plotsoff
                
                expr("define y1(x)="&func) // Lo rojo es un string
                ....
                
                //Luego graficamos usando los distintos zooms vistos en el problema 2
                
                ....
                Listo, con esto ya estamos en condiciones de graficar, facil no?
                Antecedentes
                Guia para usuarios nuevos (Leanla antes de postear)

                La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

                Comentario


                • #9
                  Solucion - Problema nº 3

                  Aca les dejo una posible solucion:

                  Etapa de ingreso y de calculos de la sumatoria:

                  Código:
                  Prgm
                  local cant,cont,aux,fun,aux2,vars,suma,config 
                  
                  {setmode("Graph","Function"),setmode("Angle","Degree")}->config // Me aseguro q la calculadora este en modo "funcion" y con angulos "Degree", y al mismo tiempo almaceno la configuracion q tenia el usuario, para luego reestablecerla.
                  
                  loop
                    {}->fun:0->suma
                    "2"->cant:"x"->aux:"y"->aux2
                    dialog
                      title "Ingreso de datos"
                      text ""
                      request "N de Funciones",cant,0
                      text""
                      request "Var. indep.",aux
                      text ""
                      request "Var. depen.",aux2
                      text ""
                    enddlog
                    if ok=0
                      exit
                    expr(cant)->cant
                    clrio
                    if cant<2 then 
                      disp "Error:",""
                      pause "Debe ingresar al menos 2 funciones."
                      exit
                    endif 
                    
                    {aux,aux2}->vars
                    
                    "0"->aux2
                    dialog
                      title "Punto de evaluacion"
                      text ""
                      request vars[1]&"o",aux2,0
                      text""
                    enddlog
                    if ok=0
                      exit
                      
                    
                    for cont,1,cant
                      "0"->aux
                      dialog
                        title "Ingreso de Funciones"
                        text ""
                        request "f"&string(cont)&"("&vars[1]&")",aux,0
                        text""
                      enddlog
                      if ok=0
                        exit
                      
                      augment(fun,{aux})->fun
                      
                      expr(aux&"|"&vars[1]&"="&aux2)+suma->suma // Calculo de la sumatoria de funciones en el punto a evaluar.
                        
                    endfor
                    ....
                    .... // Etapa de eleccion de funciones y calculo de interseccion

                  Etapa de eleccion de las funciones y calculo de interseccion:

                  Código:
                   loop
                      1->aux:1->aux2
                      dialog
                        title "Eleccion de Funciones"
                        text ""
                        dropdown "Funcion",fun,aux
                        text ""
                        dropdown "Funcion",fun,aux2
                        text ""
                      enddlog
                      if ok=0
                        exit
                      
                      clrio 
                      if string(expr(fun[aux]))=string(expr(fun[aux2])) then  // La famosa verificacion
                        disp "Error:",""
                        Pause "Las funciones son las mismas." 
                      else
                        
                        try // El try lo uso para evitar posibles errores a la hora de calcular la interseccion.
                          disp "Puntos de interseccion:",""
                          pause expr("solve("&vars[2]&"="&fun[aux]&" and "&vars[2]&"="&fun[aux2]&",{"&vars[1]&","&vars[2]&"})")  // Solve realizado con string 
                        else
                          disp "Error:",""
                          Pause "Se produjo un error de calculo." 
                        endtry
                        ....
                        ....  // Etapa para graficar
                     endif   
                      dialog 
                        title "Opcion"
                        text ""
                        text "Desea elegir otras funciones?"
                        text ""
                     enddlog
                     if ok=0
                       exit
                   endloop
                  ....
                  Etapa para graficar las funciones:
                  Código:
                        ....
                        dialog
                          title "Opcion"
                          text ""
                          text "Desea graficar?"
                          text ""
                        enddlog
                        
                        if ok!=0 then
                          FnOff
                          PlotsOff
                          expr("define y98(x)="&fun[aux]&"|"&vars[1]&"=x") // Defino y99 y al mismo tiempo defino a la variable independiente igual a x 
                          expr("define y99(x)="&fun[aux2]&"|"&vars[1]&"=x")
                          
                          {"ZoomIn","ZoomOut","ZoomDec","ZoomTrig","ZoomSqr","ZoomFit"}->aux2
                          
                          Loop
                            1->aux
                            Dialog
                              Title "Tipo de Zoom"
                              Text "      Elija el Zoom"
                              Text ""
                              DropDown "Tipo de Zoom",aux2,aux
                              Text ""
                            EndDlog
                            
                            expr(aux2[aux]) 
                            
                            Pause
                            Dialog
                              Title ""
                              Text ""
                              text "¿Desea cambiar el Zoom?"
                              Text ""
                            EndDlog
                            If ok=0
                              Exit
                          endloop
                        endif
                      endif // Mismo endif q en la etapa anterior
                      .....
                  .....
                  Ultima etapa:
                  Código:
                    clrio
                    disp "Sumatoria:",""
                    Pause "Žfi("&vars[1]&")="&string(suma)
                    
                    dialog
                      title "Opcion"
                      text ""
                      text "Desea repetir el calculo?"
                      text""
                    enddlog
                    if ok=0
                      exit  
                  endloop
                  
                  setmode("Graph",config[1])
                  setmode("Angle",config[2]) //Reestablezco la configuracion original
                  
                  delvar y1,y2
                  disphome
                  EndPrgm
                  Uso de variables:

                  cant: la cantidad de funciones q se ingresen.

                  cont: contador para el for de ingreso, de 1 a cant.

                  aux, aux2: variables usadas para almacenar de manera momentanea el ingreso de las ventanas.

                  fun: lista donde estaran las funciones ingresadas por el usuario en forma de string.

                  vars: lista donde en el primer elemento estara la variable independiente y en el segundo elemento la variable dependiente.

                  suma: tendra los valores parciales y final de la sumatoria, al principio vale 0.

                  config: lista donde el primer elemento tiene la configuracion del modo Graph y el segundo del modo Angle. (Son strings)


                  Es importante q aprendan a configurar los modos de la calculadora y q al mismo tiempo tengan en cuenta la configuracion anterior q tenia el usuario para reestablecercela. Mas acerca de la configuracion de los modos Pag. 234, 235, 236 del manual.
                  Archivos Adjuntos
                  Antecedentes
                  Guia para usuarios nuevos (Leanla antes de postear)

                  La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

                  Comentario


                  • #10
                    Concepto de Subrutinas - Problema nº 4

                    Como habia adelantado antes, en esta cuarta entrega de "Programando con cosme..." , ibamos a tratar el tema de los subprogramas y subfunciones.

                    Antes q nada vuelvo a recomendar q lean el manual de unike, mas q nada pagina 21-24, donde explica claramente las diferencias entre una funcion y un programa.

                    Para q sirven?

                    Muchas veces son utiles para evitar repetir el mismo codigo varias veces, pero tambien se pueden usar para partir un programa gigante de 4 mil lineas en pequenios programas de pocas lineas y de esa forma sea mucho mas facil de corregir a la hora de errores.

                    Sin ir mas lejos, veamos algunos ejemplos.

                    Existen 2 formas de llamar a una subfuncion o subprograma, y ambas sirven pero tienen sus pekenios detalles, veamos:

                    1- Subfuncion/Subprograma fuera del archivo del programa principal:

                    Esta es la forma mas facil de aplicar y solo debe llamar a la sub-(funcion/programa) desde el programa principal, teniendo a esta subrutina en un archivo por separado. Por ejemplo:

                    Código:
                    mainprogram()
                    prgm
                    local aux,aux2
                    input aux
                    input aux2
                    pause main\dividir(aux,aux2)
                    endprgm
                    Donde dividir es una funcion q se encuentra en la carpeta main (es importante aclarar donde esta la subrutina)

                    Código:
                    (var1,var2)
                    Func
                    return var1/var2
                    EndFunc
                    Lo uniko q hace la subfuncion es devolver la operacion (digamos q no me esfoce mucho en el ejemplo )

                    2- Subfuncion/Subprograma dentro del archivo del programa principal:


                    Esta forma la se hace poco gracias a Diego e Izerw , y a mi parecer es muy util, y funciona asi:

                    Código:
                    Prgm
                    local aux,aux2,dividir
                    
                    define dividir(var1,var2)=func
                    return var1/var2
                    endfunc
                    
                    input aux
                    input aux2
                    pause dividir(aux,aux2)
                    endprgm
                    El programa hace exactamente lo mismo q el otro, con la diferencia de q la subrutina esta dentro del programa principal. Lo unico q hice fue definir a la variable local "dividir", como una funcion, eso es todo.

                    1era Forma:

                    Ventajas de la primera forma:

                    - No tengo q definir una variable local
                    - Gasta menos ram a la hora de ejecutarse, ya q se ejecuta como un programa o una funcion por separado.

                    Desventajas:

                    - Tengo archivos sueltos por cada subrutina
                    - A la hora de archivar, esas subrutinas tb deben archivarse, pero debe tener en cuenta q todos esos archivos deben ejecutarse la 1era vez desarchivados, para lograr el mejor rendimiento (tokenizados), si esto no ocurre, la velocidad se ve perjudicada. (Las probabilidades q esto ocurra teniendo muchos archivos sueltos, es mayor)
                    - Mas compleja la instalacion del programa.

                    2da Forma:

                    Ventajas de la segunda forma:

                    - Tengo todas las subrutinas en el mismo archivo.
                    - Un solo archivo q instalar, mas facil.

                    Desventajas:

                    - El uso de Ram, a diferencia del otro ejemplo, aca se necestia ram para el programa principal y las subrutinas al mismo tiempo, lo cual si se tiene un programa muuuuy grande, esto puede generar problemas de Ram (Se los digo por experiencia, eso me paso con Ti-eq al kerer agregarle mas cosas)

                    Por ultimo hay q alcarar 2 cosas:

                    - Los nombres de las variables q se usen en el programa principal, es preferible q no se usen en las subrutinas.
                    - En caso de usar la 1era forma, se debe aclarar en q directorio se encuentra el programa, sino puede producirse un error en caso de cambiar la carpeta actual.
                    Editado por última vez por cosmefulanito04; http://www.calculadoras.cl/foro/member/618-cosmefulanito04 en 19/01/08, 07:49:27.
                    Antecedentes
                    Guia para usuarios nuevos (Leanla antes de postear)

                    La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

                    Comentario


                    • #11
                      Problema nº 4

                      Bue, vayamos a los bifes, se pide lo siguiente:

                      Hallar la serie de taylor de una funcion, en un punto y en el orden q haya ingresado el usuario.


                      Serie de Taylor - Formula

                      Condiciones:

                      - Usar una subfuncion para hallar las derivadas de la funcion ingresada, se recomienda crear una lista.
                      - Usar una subfuncion para crear un String con el resultado de la serie.
                      - Usar un subprograma para las ventanas/mensajes de error.


                      Ejmplo de lo q se pide:



                      Aca puede verse la solucion de lo q se pide:

                      http://www.calculadoras.cl/foro/show...4709#post24709

                      En estos dias voy a publicar la explicacion del codigo.

                      P.d.: no es necesario q lo hagan paso a paso.
                      P.d.2: Obviamente no se puede usar la funcion Taylor.
                      Antecedentes
                      Guia para usuarios nuevos (Leanla antes de postear)

                      La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

                      Comentario


                      • #12
                        Solucion - Problema nº 4

                        Antes q nada veamos cuales deberian ser los pasos del programa, osea la estructura:

                        - Pedimos datos, f(x), punto de evalucion, orden de la serie.
                        - Luego hallamos las derivadas necesarias para hallar la serie.
                        - Mostramos las derivadas halladas.
                        - Calculamos la serie de Taylor.
                        - Verificamos q el de la serie es correcto.
                        - Mostramos el resultado de la serie.

                        Veamos el codigo:

                        Variables locales del programa principal

                        Código:
                        local aux,aux2,aux3,aux4,aux5,calculo,derivada,error
                        Donde las variables en rojo seran subrutinas.

                        Ingreso de datos:

                        Código:
                          "0"->aux:"0"->aux2:"1"->aux3
                          dialog
                            title "Serie de taylor"
                            text ""
                            request "f(x)",aux,0
                            text ""
                            request "Xo",aux2
                            text ""
                            request "Orden 'n'",aux3
                            text ""
                          enddlog
                          if ok=0
                            exit
                          expr(aux3)->aux3:expr(aux)->aux
                          .... // Muestro la serie en general
                          {aux,0}->aux5 //  Creo una lista, donde el 1er elemento es la funcion f(x)
                        El mismo codigo de siempre.

                        Llamado a la funcion derivada:
                        Código:
                          try
                            derivada(aux,aux3)->aux
                          else
                            error()
                            exit
                          endtry
                        El llamado a la funcion esta dentro de un "try", el cual funciona como un if pero la condicion de verdadero es siempre q no haya error; en caso de haber algun error en los calculos se llama a la funcion "error". Luego vamos a ver q hacen cada funcion, lo uniko q hay q saber, es q derivada recibe "aux" (funcion ingresada f(x), en forma de expresion) y "aux3" (orden de la serie); y la funcion devuelve una lista con los distintos orden de derivadas de la funcion, hasta el orden "n"; estas derivadas se encuentran en el formato string; con el primer elemento igual a la funcion. (Ej. f(x)=x^2 n=2 => {"x^2","2x","2"}).
                        En caso de producirse un error, el subprograma "error" mostrara un cartel indicador de dicho error.

                        Muestro las derivada:

                        Código:
                          dim(aux)->aux5[2] // Almaceno la dimension de aux (lista de derivadas) en el segundo elemento de la lista aux5 (recomendacion de Unike, para no usar dim dentro del for)
                          
                          for aux4,2,aux5[2],1
                            clrio
                            disp "Derivadas:",""
                            main\imprimir("d(f(x),x,"&string(aux4-1)&")="&aux[aux4]) // imprimir lo uniko q hace es mostrar un string como si fuera una expresion, con la ventaja de no simplificar nada (ideal para paso a paso)
                          endfor
                        Llamado a la subfuncion calculo:

                        Código:
                          try
                            calculo(aux,aux2,aux3)->aux
                          else
                            error()
                          endtry
                        "Calculo" recibe aux (lista de derivadas), aux2 (punto de evalucion), aux3 (orden de la serie), y por ultimo devuelve un string con la forma de la serie, de esta forma se puede mostrar el string completo usando imprimir y no simplificar nada.

                        Mostrar el resultado de la serie:

                        Código:
                          if string(expand(taylor(aux5[1],x,aux3,expr(aux2)),x))=string(expr(aux)) then
                          
                            clrio
                            disp "Serie de Taylor:",""
                            main\imprimir("f(x)="&aux)
                          
                            clrio
                            disp "Serie de Taylor:",""
                            main\imprimir("f(x)="&string(expr(aux)))
                          
                          else
                            error()
                          endif
                        Se imprime el resultado, primero sin simplificar y luego simplificado, y en caso de producirse un error, se llama al subprograma "error".

                        El resto siempre es igual, se repite la secuencia tantas veces kiera el usuario.

                        Ahora veamos las subrutinas por separado:

                        Funcion derivada

                        Código:
                        define derivada(var1,var2)=func
                        local cont,lista  // Variables locales de la funcion derivadas
                        {string(var1)}->lista // Lista q devolvera la funcion, cuyo 1er elemento es f(x) en string 
                        for cont,1,var2,1
                          augment(lista,{string(d(var1,x,cont))})->lista // Se van agregando las derivadas de orden en un string
                        endfor
                        return lista // Devuelvo la lista creada
                        endfunc
                        Funcion calculo

                        Código:
                        define calculo(var1,var2,var3)=func
                        local cont,cadena // Variables locales de la funcion calculo
                        
                        for cont,0,var3,1
                          if cont=0 then
                            string(expr(var1[cont+1]&"|x="&var2))->cadena // Cadena sera el string q se devuelve, y al principio contiene f(x) evaluado en Xo, todo en string.
                          else
                            cadena&"+"&"(1/"&string(cont)&"!)*"&string(expr(var1[cont+1]&"|x="&var2))&"*(x-"&var2&")^"&string(cont)->cadena // En caso de ser orden distinto de 0, osea cont=1, se agregara a la cadena el termino de la serie evaluado en Xo, todo en string.
                          endif
                        endfor 
                        return cadena // Por ultimo se devuelve la cadena
                        endfunc
                        Subprograma Error:
                        Código:
                        define error()=prgm
                          dialog
                            title "Error"
                            text ""
                            text "Se produjo un error de calculos."
                            text ""
                          enddlog
                        endprgm
                        En resumen, las subrutinas son utiles para convertir un programa complicado en varios subprogramas menos complicados, y al mismo tiempo aislados de errores entre las funciones (obviamente q si se depende de argumentos, habra un error, pero debido a un problema con el argumento en si).

                        En este caso, la funcion derivada, podria haberse obviado por el hecho de q se necesita un for para generar la lista y otro para mostrarla, tal vez lo conveniente hubiera sido imprimir los resultados desde la funcion, pero al ser una funcion, no se permite el uso de los comandos "disp", "pause", etc. Igualmente la idea era mostrar como trabajan las subfunciones.
                        Antecedentes
                        Guia para usuarios nuevos (Leanla antes de postear)

                        La mayoria de los programas hechos en ti-basic funciona solamente con el idioma en Ingles.

                        Comentario

                        Trabajando...
                        X