| //+------------------------------------------------------------------+
|
| //| UEPar.mq5 |
|
| //| Copyright 2026, Niquel Mendoza. |
|
| //| https://www.mql5.com/ |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2026, Niquel Mendoza."
|
| #property link "https://www.mql5.com/"
|
| #property version "1.00"
|
| #property strict
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| #define TSNTABLES_SWAR_MASK_BACK_SLASH (0x5C5C5C5C5C5C5C5C)
|
| #define TSNTABLES_SWAR_MASK_COMILLA (0x2222222222222222)
|
| #define TSNTABLES_SWAR_LO 0x0101010101010101
|
| #define TSNTABLES_SWAR_HI 0x8080808080808080
|
| #define TSNTABLES_SWAR_HAS(mask) ((mask - TSNTABLES_SWAR_LO) & ~mask & TSNTABLES_SWAR_HI)
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| template <typename T>
|
| string ToBits(T v)
|
| {
|
| string str = "";
|
| for(int i = (sizeof(T) << 3) - 1 ; i >= 0; i--)
|
| {
|
| str += string(uchar((v & (1ULL << i)) == 0 ? 0 : 1));
|
| }
|
| return str;
|
| }
|
| //+------------------------------------------------------------------+
|
| // 110
|
| // 010
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| Script program start function |
|
| //+------------------------------------------------------------------+
|
| void OnStart()
|
| {
|
| union U
|
| {
|
| ulong v;
|
| uchar data[8];
|
| };
|
|
|
| U va;
|
| va.data[0] = '"';
|
| va.data[1] = '\\';
|
| va.data[2] = '"';
|
| va.data[3] = 'b';
|
| va.data[4] = '{';
|
| va.data[5] = 'g';
|
| va.data[6] = '"';
|
| va.data[7] = '1';
|
| // 8=\
|
| // 9=\
|
|
|
|
|
| ulong str = va.v;
|
|
|
| //---
|
| // 1100 0000 10
|
| // 1100 0000 1100 0000
|
| // 0000 0000
|
|
|
| //---
|
| ulong x_bs = str ^ TSNTABLES_SWAR_MASK_BACK_SLASH;
|
| ulong x_qt = str ^ TSNTABLES_SWAR_MASK_COMILLA;
|
| ulong has_bs = TSNTABLES_SWAR_HAS(x_bs);
|
| ulong has_qt = TSNTABLES_SWAR_HAS(x_qt);
|
|
|
|
|
| //--- Metodo base
|
| ulong bits = has_bs >> 7;
|
| const ulong magic = 0x0102040810204080;
|
| const uchar compacted_bs = uchar(((bits * magic) >> 56) & 0xFF);
|
| Print(ToBits(compacted_bs));
|
| const uchar even_mask = B'10101010';
|
|
|
| uchar a = (((compacted_bs << 1) | even_mask) - compacted_bs) ^ even_mask;
|
| Print("Dez: ");
|
| Print(ToBits(uchar(compacted_bs << 1)));
|
| Print("Or with impar: ");
|
| Print(ToBits(uchar((compacted_bs << 1) | even_mask)));
|
| Print("Minus: ");
|
| Print(ToBits(uchar(((compacted_bs << 1) | even_mask) - compacted_bs)));
|
| Print("Final:");
|
| Print(ToBits(a));
|
|
|
| uchar escaped = a ^ compacted_bs;
|
| uchar escape = (a & compacted_bs) >> 7;
|
| Print("overflow: ", escape);
|
|
|
| /* uchar starts = compacted_bs & ~(compacted_bs << 1);
|
| Print("starts");
|
| Print(ToBits(starts));
|
|
|
| uchar starts_par = starts & even_mask;
|
| uchar starts_impar = starts & ~even_mask;
|
|
|
|
|
|
|
| Print("starts f");
|
| Print(ToBits(starts_par));
|
| Print(ToBits(starts_impar));
|
| uchar sum_par = compacted_bs + starts_par;
|
| const ushort sum_impar_wide = (ushort)compacted_bs + ushort(starts_impar);
|
| Print("sum f");
|
|
|
| Print(ToBits(sum_par));
|
| Print(ToBits(sum_impar_wide));
|
|
|
|
|
| uchar end_par = sum_par & ~compacted_bs;
|
| uchar end_impar = uchar(sum_impar_wide & 0xff) & ~compacted_bs;
|
| Print("end");
|
| Print(ToBits(end_par));
|
| Print(ToBits(end_impar));
|
|
|
| Print("---");
|
| Print("ImPar mask : ", ToBits(even_mask));
|
| Print("Par mask : ", ToBits(uchar(~even_mask)));
|
| Print("end impr mask: ", ToBits(uchar(end_impar & even_mask)));
|
| Print("end par mask : ", ToBits(uchar(end_par & ~even_mask)));
|
|
|
| uchar end_final = (end_impar & even_mask) | (end_par & ~even_mask);
|
| Print("end final");
|
|
|
| Print(ToBits(end_final));
|
|
|
|
|
| Print(ToBits(Q_real));*/
|
|
|
|
|
| bits = has_qt >> 7;
|
| const uchar compacted_qt = uchar(((bits * magic) >> 56) & 0xFF);
|
| uchar Q_real = compacted_qt & ~escaped;
|
| Print(ToBits(Q_real));
|
|
|
|
|
| Q_real ^= Q_real << 1;
|
| Q_real ^= Q_real << 2;
|
| Q_real ^= Q_real << 4;
|
|
|
| Print(ToBits(Q_real));
|
|
|
| uchar prev_in_string = 0U;
|
|
|
| const uchar in_string = Q_real ^ prev_in_string;
|
| Print(ToBits(in_string));
|
|
|
|
|
| prev_in_string = uchar(char(in_string) >> 7);
|
| Print(ToBits(prev_in_string));
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| /*
|
| 00000001
|
| \\a\\\b"
|
| 11011100 <<1
|
| // A este punto ya se tendriaa los caracteres qeu son escapados
|
| // Bastaria con un AND Para terminar pero nota que hay un tema el overflow
|
| // Y los impares y el tema de las rachas.. creo qeu eso solo funcionara si no
|
| // hubieran rachas y solo \ dispersos ahi si te draia los chars que se "escapan"
|
| 10111000
|
|
|
| // Bueno a difernica del otro algoritmo que note qeu es mas grande
|
| // dado que separa en dos rutas el tema de pares\impares
|
| // obtiebne inicios y con accareo los fines de las rachas y luego compara
|
| // con posiciones y se apagan\prendn bits dependei si es valido
|
| // Acada la idea es no hacen todo ese trabajo si no solo ver los chars
|
| // Que se escapan y no se escapan en base a eso luego aplicaremo la mascara final
|
| // Ahora con el or lo que haremos sera añadirle una mascara con los impartes
|
| // Por lo qeu vi esto tiene que ver ocn la resta que viene..
|
| // Dado uqe con eso el tema del prestamo que sehace y tambien las posiciones
|
| // Impares
|
| // Dado que las posiciones imapres.. para que quede espcaod
|
| // EL caracter final (+1) debe quedar en posicion par
|
| // Entonces con las rachas esto creo qeu normaliza inciae,te
|
| // Lugeo igual se decahe con un xor (aun no me queda muy calro a decir verdad)
|
| // Pero si ver el resultado del esciprt empiza a tener sentdio
|
| 10111000 | or
|
| 10101010
|
| --------
|
| 10111010
|
|
|
| // Luego de eso aplicamos una resta esto es interesante dadao
|
| // Que como esmotas resntando uno "norma" y otr odesfasdo enotnces incial
|
| // resta 0-1 lo qeu descandena ese "prestamo".. el tema es que
|
| // mietrnas dure la racha ira repestandose luego al terminar la racha cuando
|
| // se restop con 0 ahi termina creo que la idea aqui era como mezaclar
|
| // ese reusltao hace que con ese or pareec que todo qeuda "pares"
|
| // Lo otro interesante es qeu aun el resutlado esta a medias
|
| // No peudefs scaar conlcusion luego con el xor final se limpia mas
|
| // Y queda que los pares su caracter inicla queda como 0
|
| // luego los impares el caracter a escapar qeuda como 1..
|
| // Esto es porducot de la resta y eso de los paraes muy psible sea por el | or que hicmos
|
| 10111010 -
|
| 11011100
|
| --------
|
| 11011110
|
|
|
| // Ahora limpaismo con xor (los iguales en si los 1-1 se ahcen 0)
|
| 11011110 xor
|
| 10101010
|
| --------
|
| 01110100
|
|
|
| // Por ultimo aplicamos otro xor pero ya no liapdf la msarca si no sobre
|
| // El conujutno real esto lo que nos deja es 1 en las posicones que se "escapan"
|
| // Luego la idea sera voltear este reusltado y apliucar un and sobre el qt
|
| // y ahi sacas las posicones que se requiren
|
| 01110100
|
| 11011100 xor
|
| --------
|
| 10101000
|
|
|
| 01110
|
| 0001
|
| 111
|
| */
|
|
|
| //+------------------------------------------------------------------+
|
| // 11011100 Base
|
| // 10111000 << 1 para deteerminar el fin de cada racha y el bit niical de cada racha queda en 0 (previo a una rahca hay un 0)
|
| // Ahora volteas el reusltoad y ahora donde habia 0 hay 1... lo intresante es que los incios de las rachas ahora tienen
|
| // 01000111 ~
|
| // un 1.. entonces loq eu falta por hacer es dejar eoss 1.. eso lo haremos ahora..
|
| //---
|
| // 01000111 & // para limpiar
|
| // 11011100
|
| // 01000100
|
| // A este punto tenemos 1 en donde empizar las rachas..
|
| // ahora la idea sera versi son impartes o pares.. si son pares aisalmos los bits donde son el fin de la racha
|
| // y luego aplicamsoo una mascara de " y ahi nos da los que si son
|
| //---
|
| // Luego se hace and con mascaras con pares.. la idea es procesar por
|
| // separado las maracas de rachas pares e impares.
|
| //--- Starts par por ejemplo..
|
| // 01000100 (se queda tal cual)
|
| // 11011100 + // se suma con los starts esto hace que se valle prestando 1 (1+1 inicial) y al final de la racha par deje un bit prendido
|
| //[1]00100000
|
| // Luego la idea es que pro ejemplo con las rachas pares seapramos su inico...
|
| // Y marcamos los incios pares ahi...
|
| // Luego con acarreo tenemos los finaes..
|
| // Ahora para los inicios pares.. la idea es que tambien acaben en posiciones pares (caracter + 1)
|
| // ejemplo [0][1][2]
|
| // \ \ aqui si acaba en un par (buneo un impar + 1) en este caso acabo en 2
|
| // entonces bien.... aqui se qeudaira un bit prendido en 1 luego cuando combinemos ambas rachas
|
| // para los pares negamos la mascara de 01010101 osea se hace una mascara de impares
|
| // la idea e sque al hacer and en caso la racha acabe en impares... su bit se mantine esi no se hace 10
|
| // esto es interensate luego que en la negacion final.. esos bits pasan a ser 0.. (los 1..)
|
| // es como una liuempiza.. entonces quedan los bits prendidos los end validos... no escapados
|
| // luego ahi una and con la mcarsa de qt y listo qeudan los bits con " validos
|
