Librerías: mt-R - página 3
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
Hola,
Estoy tratando de utilizar la función RAssignStringVector, pero parece que sólo el primer char de cada término se copia a la sesión de R.
Por ejemplo el vector MQL5
{"abcd","2000","2000}
se copia en R como
{"a", "2", "2"}
¿Es un problema o estoy equivocado?
Ten en cuenta que estoy usando RAssignVector con vector doble sin problemas.
Gracias.
Claudio.
Yo no uso MT5, lo siento
Atención.
En el archivo R.mqh los nombres de las variables vector y matrix empezaron a generar un error durante la compilación. Cámbiales el nombre por otros y todo funcionará. He utilizado vectr y matr.
El editor resalta estas palabras en azul como un tipo de datos como int, double. Aparentemente son palabras reservadas para nuevos tipos.
Descripción de todas las funciones (copiadas de la versión anterior https://www.mql5.com/en/code/11112)
/**
* Devuelve la versión del dll. Los 16 bits superiores del valor devuelto
* son la versión mayor y los 16 bits inferiores la menor. Esto
* se usa en RInit() para asegurarse de que este fichero de cabecera y
* zzla dll encajan.
*/
int RGetDllVersion();
/**
* Esto no está pensado para ser llamado directamente, será
* llamado por RInit() después de la comprobación de versión exitosa.
* Debe llamar a RInit() para iniciar una nueva sesión de R.
*/
long RInit_(string commandline,int debuglevel);
/**
* Teminate the R session. Llame a esto en su función deinit().
* Después de esto el handle ya no es válido.
*/
void RDeinit(long rhandle);
/**
* return true if the R session belonging to this handle is
* still running. R terminará ante cualquier error fatal en el
* código que le envíe. Debería comprobar esto al principio
* de su función de inicio y detener todas las acciones. El último
* comando antes de la caída se encontrará en el log.
* Si R ya no se está ejecutando esta librería no emitirá ningún
* mensaje más de log e ignorará silenciosamente todos los comandos.
*/
bool RIsRunning(long rhandle);
/**
* return true if R is still executing a command (resulting
* de una llamada a RExecuteAsync())
*/
bool RIsBusy(long rhandle);
/**
* ejecuta código y no espera. Sin embargo, cualquier llamada posterior
* esperará ya que sólo puede haber un hilo ejecutándose en
* un momento dado. Utilice RIsBusy() para comprobar si ha terminado
*/
void RExecuteAsync(long rhandle,string code);
/**
* ejecuta el código y espera hasta que termine. Esto no
* devolverá nada. Básicamente puedes conseguir lo mismo con
* las funciones RGet*(), evaluar la expresión es también
* simplemente ejecutar código, la única diferencia es que estas
* funciones RGet*() intentarán además analizar y devolver
* la salida mientras que RExecute() simplemente ejecutará, esperará e
* ignorará toda la salida.
*/
void RExecute(long rhandle,string code);
/**
* asignar un bool al nombre de la variable. En R este tipo se llama "lógico"
*/
void RAssignBool(long rhandle,string variable,bool value);
/**
* asignar un entero al nombre de la variable.
*/
void RAssignInteger(long rhandle,string variable,int value);
/**
* asigna un double al nombre de la variable.
*/
void RAssignDouble(long rhandle,string variable,double value);
/**
* asignar una cadena a la variable namd. En R este tipo se llama "carácter"
*/
void RAssignString(long rhandle,string variable,string value);
/**
* asignar un vector a la variable nombre. Si el tamaño no coincide con
* el tamaño real del array, pueden ocurrir cosas malas.
*/
void RAssignVector(long rhandle,string variable,double &vectr[],int size);
/**
* asigna un vector de caracteres (un array de cadenas) a la variable. Si necesita
* un factor, deberá ejecutar código para convertirlo después de este comando. En
* versiones recientes de R un vector de cadenas no necesita más memoria que
* un factor y es más fácil añadirle nuevos elementos.
*/
void RAssignStringVector(long rhandle,string variable,string &vectr[],int size);
/**
* asignar una matriz al nombre de la variable. La matriz debe tener el número de fila como
* primera dimensión (se utilizará byrow=TRUE en los datos brutos). Esta función es mucho
* más rápida que construir una matriz enorme (cientos de filas) desde cero añadiendo
* nuevas filas al final con RRowBindVector() para cada fila. Esta función está optimizada
* para un enorme rendimiento con una sola llamada a la función mediante el uso de archivo-IO con los
* datos binarios en bruto. Para matrices muy pequeñas y vectores con sólo un puñado de elementos
* esto podría ser demasiada sobrecarga y las otras funciones serán más rápidas. Una vez que
* tenga la matriz con posiblemente miles de filas transferidas a R debería entonces
* sólo usar RRowBindVector() para hacerla crecer lentamente a la llegada de nuevos
* vectores de datos en lugar de enviar siempre una nueva copia de la matriz entera.
*/
void RAssignMatrix(long rhandle,string variable,double &matr[],int rows,int cols);
/**
* añadir una fila a una matriz o marco de datos. This will exexute
* variable <- rbind(variable, vector)
* if the size does not match the actual array size bad things might happen.
*/
void RAppendMatrixRow(long rhandle,string variable,double &vectr[],int size);
/**
* return true if the variable exists, false otherwise.
*/
bool RExists(long rhandle,string variable);
/**
* evalúa la expresión y devuelve un bool. La expresión puede ser cualquier código R
* que se evalúe como lógico. Si es un vector de lógicas, sólo se devuelve
* el primer elemento.
*/
bool RGetBool(long rhandle,string expression);
/**
* evalúa la expresión y devuelve un entero. La expresión puede ser cualquier código R
* que se evalúe como un entero.
Si es un punto flotante se redondeará, si es un vector sólo se devolverá el primer elemento.
*/
int RGetInteger(long rhandle,string expression);
/**
* evalúa la expresión y devuelve un doble. La expresión puede ser cualquier código R
* que se evalúe a un número de coma flotante, si es un vector entonces
* sólo se devuelve el primer elemento.
*/
double RGetDouble(long rhandle,string expression);
/**
* evalúa la expresión y devuelve un vector de dobles. La expresión puede ser
* cualquier cosa que se evalúe como un vector de números de coma flotante.
* El valor devuelto es el número de elementos que podrían copiarse en la matriz
*. Nunca será mayor que el tamaño, pero puede ser menor.
* se muestran advertencias en el nivel de depuración 1 si los tamaños no coinciden.
* Limitado a 100000 elementos
*/
int RGetVector(long rhandle,string expression,double &vectr[],int size);
/**
* realiza un print(expression) para propósitos de depuración. La salida será
* enviada al monitor de depuración en el nivel de depuración 0.
*/
void RPrint(long rhandle,string expression);