258 lines
9 KiB
MQL5
258 lines
9 KiB
MQL5
//+------------------------------------------------------------------+
| |
//| 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
|