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
|