| 3 |   | Aún por completar. Véase [wiki:TOL_R_Integration]. | 
                      
                      
                        |   | 3 | == Introducción == | 
                      
                        |   | 4 |  | 
                      
                        |   | 5 | El paquete {{{TolRInside}}} de TOL permite la comunicación natural de TOL con R.  | 
                      
                        |   | 6 |  | 
                      
                        |   | 7 | Es el paquete equivalente al paquete [wiki:tolLink] de R, pero en el otro sentido de la comunicación.  | 
                      
                        |   | 8 | Aunque en principio éstos podrían ser independientes, como veremos, juntos permiten una comunicación bidireccional. | 
                      
                        |   | 9 |  | 
                      
                        |   | 10 | Para poder utilizar TolRInside necesitamos una versión de TOL compatible con R.  | 
                      
                        |   | 11 | Para ello disponemos de una variante de TOL compilada con GNU GCC denominada TOL-GNU. | 
                      
                        |   | 12 | Esta versión está disponible en: [wiki:DownloadTol#Extras]. | 
                      
                        |   | 13 | Para más detalles sobre la instalación de TOL y R, véase: [wiki:R_TOL_R_Installation R<<TOL>>R Instalación]. | 
                      
                        |   | 14 |  | 
                      
                        |   | 15 | == Funciones == | 
                      
                        |   | 16 |  | 
                      
                        |   | 17 | El paquete {{{TolRInside}}} publica un conjunto de funciones al ser requerido, de modo que éstas pasan a ser funciones globales en TOL. | 
                      
                        |   | 18 |  | 
                      
                        |   | 19 | La principal de estas funciones es {{{REval}}} y de ella derivan otras como: {{{RCall}}}, {{{RExecute}}} o {{{RLibrary}}}. | 
                      
                        |   | 20 |  | 
                      
                        |   | 21 | === REval === | 
                      
                        |   | 22 |  | 
                      
                        |   | 23 | La función {{{REval}}} recibe un sólo argumento que corresponde con una expresión de R.  | 
                      
                        |   | 24 | El resultado de su evaluación será exportado a TOL y devuelto como salida de la llamada a {{{REval}}} si existe el mecanismo de conversión oportuno. | 
                      
                        |   | 25 |  | 
                      
                        |   | 26 | Ejemplos: | 
                      
                        |   | 27 | {{{ | 
                      
                        |   | 28 | #!java | 
                      
                        |   | 29 | // Conjunto de atributos con la versión de R en uso: | 
                      
                        |   | 30 | Set REval("version");  | 
                      
                        |   | 31 | // Texto con la versión de R | 
                      
                        |   | 32 | Text REval("version$version.string"); | 
                      
                        |   | 33 | // Con idéentico resultado podemos ejecutar: | 
                      
                        |   | 34 | Text REval("version")["version.string"] | 
                      
                        |   | 35 | }}} | 
                      
                        |   | 36 |  | 
                      
                        |   | 37 | === Errores === | 
                      
                        |   | 38 |  | 
                      
                        |   | 39 | Si intentamos obtener un objeto sin conversión en TOL, encontraremos un error. Por ejemplo: | 
                      
                        |   | 40 | {{{ | 
                      
                        |   | 41 | #!java | 
                      
                        |   | 42 | Anything REval("sin"); | 
                      
                        |   | 43 | // > ERROR: [] R class 'function' is not implemented. | 
                      
                        |   | 44 | // Ya que no está implementada la conversión de un objeto de tipo "function" de R a TOL. | 
                      
                        |   | 45 | }}} | 
                      
                        |   | 46 |  | 
                      
                        |   | 47 | Si evaluamos una expresión con errores obtendremos un error sin ninguna otra información que nos ayude a detectarlo: | 
                      
                        |   | 48 | {{{ | 
                      
                        |   | 49 | #!java | 
                      
                        |   | 50 | // > ERROR: [] Exception caught: Error evaluating: ... | 
                      
                        |   | 51 | }}} | 
                      
                        |   | 52 |  | 
                      
                        |   | 53 | Este tipo de mensaje de error, nos indica básicamente que se encontraron errores intentando evaluar la expresión. | 
                      
                        |   | 54 |  | 
                      
                        |   | 55 | === Comunicación de variables === | 
                      
                        |   | 56 |  | 
                      
                        |   | 57 | Para trasladar una variable de TOL hasta R, podemos hacer uso del paquete [wiki:tolLink] y concretamente de su función {{{tolGet}}}. | 
                      
                        |   | 58 |  | 
                      
                        |   | 59 | Ejemplos: | 
                      
                        |   | 60 | {{{ | 
                      
                        |   | 61 | #!java | 
                      
                        |   | 62 | // Se carga tolLink en R | 
                      
                        |   | 63 | Set REval("library(tolLink)"); | 
                      
                        |   | 64 | Real a = 1; | 
                      
                        |   | 65 | // Se pide a R que obtenga el valor de a y calcule el seno | 
                      
                        |   | 66 | Real sin_a = REval("sin(tolGet('a'))"); | 
                      
                        |   | 67 | }}} | 
                      
                        |   | 68 |  | 
                      
                        |   | 69 | === RCall === | 
                      
                        |   | 70 |  | 
                      
                        |   | 71 | Nótese, en el ejemplo anterior, que la carga de tolLink devuelve un conjunto que no nos interesa. | 
                      
                        |   | 72 |  | 
                      
                        |   | 73 | Para evitar traer ese resultado u obtener un error en el caso de que la evaluación resulte  | 
                      
                        |   | 74 | en un objeto que no puede convertirse podemos acabar nuestra expresión con un número: | 
                      
                        |   | 75 | {{{ | 
                      
                        |   | 76 | #!java | 
                      
                        |   | 77 | Real REval(" | 
                      
                        |   | 78 | library(tolLink) | 
                      
                        |   | 79 | 1 | 
                      
                        |   | 80 | "); | 
                      
                        |   | 81 | }}} | 
                      
                        |   | 82 | o usar la función {{{RCall}}}: | 
                      
                        |   | 83 | {{{ | 
                      
                        |   | 84 | #!java | 
                      
                        |   | 85 | Real RCall("library(tolLink)"); | 
                      
                        |   | 86 | }}} | 
                      
                        |   | 87 |  | 
                      
                        |   | 88 | === RLibrary === | 
                      
                        |   | 89 |  | 
                      
                        |   | 90 | Aún más, para la carga de paquetes en R, hay implementada una función específica: {{{RLibrary}}}. De este modo, simplemente debemos hacer: | 
                      
                        |   | 91 | {{{ | 
                      
                        |   | 92 | #!java | 
                      
                        |   | 93 | Real RLibrary("tolLink"); | 
                      
                        |   | 94 | }}} | 
                      
                        |   | 95 |  | 
                      
                        |   | 96 | === RExecute === | 
                      
                        |   | 97 |  | 
                      
                        |   | 98 | Otro modo de llamar a una función de R y enviar argumentos de TOL es usar {{{RExecute}}}, análoga a la función {{{tolExecute}}} de [wiki:tolLink]. | 
                      
                        |   | 99 |  | 
                      
                        |   | 100 | El primer argumento de la función corresponde con el nombre de la función de R. El segundo es un conjunto con la lista de argumentos a pasar a la función. | 
                      
                        |   | 101 |  | 
                      
                        |   | 102 | Ejemplos: | 
                      
                        |   | 103 | {{{ | 
                      
                        |   | 104 | #!java | 
                      
                        |   | 105 | Real b = 1; | 
                      
                        |   | 106 | Real sin_b = RExecute("sin", [[b]]); | 
                      
                        |   | 107 | Real atan_1_2 = RExecute("atan2", [[1, 2]]); | 
                      
                        |   | 108 | }}} | 
                      
                        |   | 109 |  | 
                      
                        |   | 110 | Si queremos pasar a la función un atributo con nombre le antepondremos "__" al nombre de la variable en TOL. | 
                      
                        |   | 111 |  | 
                      
                        |   | 112 | Ejemplo: | 
                      
                        |   | 113 | {{{ | 
                      
                        |   | 114 | #!java | 
                      
                        |   | 115 | // Para llamar a paste("a", "b", sep="-") podemos hacer: | 
                      
                        |   | 116 | Text RExecute("paste", [["a", "b", Text __sep="-"]]); | 
                      
                        |   | 117 | }}} | 
                      
                        |   | 118 |  | 
                      
                        |   | 119 | == Otra información == | 
                      
                        |   | 120 |  | 
                      
                        |   | 121 | Véase [wiki:TOL_R_Integration]. |