PMCA Pattern Matching Compression Algorithm

//PMCA Patter Matching Compression Algorithm

/*
//currently a work in progress

//use something like ani-prime numbers, factor and compress the factors

var fact=[37,41,17, 23],

nom=37*41*17*23;

*/

//huffman coding partial
arr2="a,100,g,35,c,34,d,9,m,2,u,2".split(",").reverse();
arr=[]
i=0; L=arr2.length;
while(i!=L){ arr.push([arr2[i]*1,arr2[i+1]]); i+=2;}

f0=arr.splice(0,2);
arr.unshift([f0[0][0]+f0[1][0],f0]);
arr.sort(function(a,b){ return a[0]>b[0]; });
arr.length;




//make patterns table at beginning like PNG & DNS domain format, have different sections for different length matches, with section 0 being 8 bit (smallest searched match)

"1 being 9 bits, 2=10, 3=11, 4=12, 5=13, and so on (num+=8)";

//sections begin with 2 bytes telling how many matches there are, round up length to the next byte to make parsing and saving this compression format easier.

//sections for exact match, factors, XOR match

//I feel like Math.log may come in handy somewhere




DataView.prototype.getString=function(bi,L){
 var i=0,s="";
 while(i!=L){
  s+=String.fromCharCode(this.getUint8(bi+i));
  i++;
 }
 return s;
};


DataView.prototype.setString=function(bi,s){
 var i=0,L=s.length;
 while(i!=L){
  this.setUint8(bi+i,s.charCodeAt(i));
  i++;
 }
};



self.strNui8=function strNui8(s,ui8,u8i){
 var L=s.length,i=L;
  while(i--) ui8[u8i+i]=s.charCodeAt(i);
};


self.ui8Gstr=function Ui8Gstr(ui8,i,L){
 var s="";
  while(i!=L){ s+=String.fromCharCode(ui8[i]); i++; }
  return s;
};




self.test_str="This is a very loooong test string for compression method, must use bitwise NOR? denoted by ^ in javascript to find bit similarities and difference which can be eventual after many iterations translated to 'patterns' for the PMCA Pattern Matching Compression Algorithm. I guess this is the end for now. END";


lel=test_str.length;

self.ui8_1=new Uint8Array(lel);

strNui8(test_str,ui8_1,0);





//new
tak=function(ui16,ui16_2){
 var L=ui16.length,i=0,n,z=0;
  while(i!=L){
   ui16_2[i]=(n=ui16[i])^(z+(n>>1));
   z=(n&1)<<15;
   i++;
  }
};
tuk=function(ui16,ui16_2){
 var L=ui16.length,i=0,n,z=0;
  while(i!=L){
   ui16_2[i]=(n=ui16[i])^(z+(n<<1));
   z=n>>15;
   i++;
  }
};

rtak=function(ui16,ui16_2){
 var L=ui16.length,i=L,n,z=ui16[L-2]&1;
  while(i--){
   ui16_2[i]=(n=ui16[i])^(z+(n>>1));
   z=(n&1)<<15;
  }
};
rtuk=function(ui16,ui16_2){
 var L=ui16.length,i=L,n,z=ui16[L-2]>>15;
  while(i--){
   ui16_2[i]=(n=ui16[i])^(z+(n<<1));
   z=n>>15;
  }
};






//counting repetitions, gaps
self.pat1=function pattern1(ui8_){
var map=[],n=16, Lim=[],cc,w=0,i=0, L=ui8_.length;
while(n--) map.push([]); na=map[0];
n=16; while(n--)Lim.push(0);
while(i!=L){
  cc=ui8_[i];
  map[n=cc>>4].push(w-Lim[n]);  Lim[n]=w;
  w++;
  map[n=cc&15].push(w-Lim[n]);  Lim[n]=w;
  i++; w++;
 }

 return map;
};

//counting repetitions of gaps in repetitions, counting gaps in present numbers;
self.UltMp=function ultraMap(zz){ //zz=map[n];
var i=zz.length,z2=[],z3=[],z4=[],L,Lb;
while(i--) if(z2.indexOf(zz[i])==-1) z2.push(zz[i]);

z2.sort(function(a,b){return a>b;});

i=0; L=z2.length;
Lb=0;
while(i!=L){ z3[i]=z2[i]-Lb; Lb=z2[i]; i++;}

i=0; L=zz.length;
while(i!=L){ z4[i]=z2.indexOf(zz[i]); i++;}

return [z2,z3,z4];
};


self.map1=pat1(ui8_1);


self.reMap=function(a){ var mp2=UltMp(a); return ([mp2[1].length]).concat(mp2[1],mp2[2]); };
//reMap is awesome! :)

mp1=reMap(map1[0]);

self.uncraam=function(ia){ //reverse the mp2[1] part of reMap to get the mp2[0] part
 var i=0,L=ia.length,Lst=0,ra=[];
 while(i!=L){ ra[i]=ia[i]+Lst; Lst=ra[i]; i++;}
 return ra;
};


//begin BITmp;   after reMap(s), array size is 1.5ish what it was, but after BITmp, it will be much smaller
self.BITmp=function BIT_MAP(a){
 //step 1, get largest number, get its bit length:
 var Ln=0,L=a.length,i=L; while(i--) if(a[i]>Ln)Ln=a[i];
 var bL=Ln.toString(2).length; //bitLength, number of bytes needed for seq
 var cv,c2=0,c3=0,Lv=-1,ri=1, MV=(1<<bL)-1;
 ra=[bL]; //byte length (max) is first,  treat ra as uint_bL array,
 //seq, number to repeat & number repetition count
 i=0;
    //WUT (doesn't work)
 while(i!=L){ cv=a[i];
 if(cv==Lv){ c2++; if(c3){ra[] } c3=0;}
 else{ c3++; if(c2>3) ra[]; c2=0;}
 Lv=cv; i++;}
 return ra;
};


//make 2, 3, 4, 5, 6, 7 diminsional "'arrays'" of the data and find (straight?) paths of matching bits?
//2d = (width*y_pos)+x_pos; 3d = (width*height*z_pos)+(width*y_pos)+x_pos; 4d=(width*height*depth*v_pos)+(width*height*z_pos)+(width*y_pos)+x_pos;

//make size match 8 length cube? bits not bytes so do nothing to length is already 2 diminsions, divide by 8 once is 3 diminsions, twice is 4 dimensions and so on

self.dimensionator=function(Len){
 var din=2; if((!Len)||typeof Len!="number") return 0;
 while((Len>>=3)>3) din++;  //whis is >3 ? I know >>=3, but why >3 ?
//args = coords = x,y,z,a,b,c,d,e,f; etc. aka dimensions 1,2,3,4,5,6,7,8,9 etc.
 var rez=new Uint16Array(din),i=0,t3=0;
 while(i!=din){ rez[i]=t3; i++; t3+=3; }
 return [din,rez];
};

 //because we're using >>=3, aka /=8, then each value in cor "should?" never be biger than 7, so we only need 3 bits per element


self.getBitAtCoord=function(cor,sps,ui8){ //sps = shift amount array
//cor = (Array)coords = x,y,z,a,b,c,d,e,f; etc. aka dimensions 1,2,3,4,5,6,7,8,9 etc.; use only the diminsions that exist

 var L=cor.length,rr=0,i=1,t3=0, x_c=cor[0];
 //test weather using sps: cor[i]<<sps[i]; or just multiplying i by 3 is faster: cor[i]<<(3*i); or use t3 again: t3=0; while() cor[i]<<t3; i++;t3+=3;
 while(i!=L){ rr+=(cor[i]<<t3); i++; t3+=3; }

 if(!ui8) return (rr<<3)+x_c;
 //cor[0], aka "x" is the simplest, so it is only the bit index inside the byte, so skip it
 return (ui8[rr]&(1<<(7-x_c)))&&1;
};


self.rres=function(n,d){ var r=n%d; return [(n-r)/d,r];}; //(division with remainder, probly need later)



self.scrubit=function(u8){ //(pat1 v2) (doesn't work yet)
 var le=[],lm=[],i=16,L=u8.length,w=0,
 bep=u8[0]<<4,b0p=4,n;
 while(i--){le[i]=[];lm[i]=0;}

 while(i<L){
  if(b0p==8){i++; b0p=0; bep|=u8[i]; }
  le[n=(bep>>8)].push(w-lm[n]); lm[n]=w; n=4095&(bep<<1);bep=n; w++; b0p++;
 }
 return le;
};


//end of newest part



//something like this:
dv1=new DataView(ab); L=dv1.byteLength;
self.c1=0; self.haz=[]; self.c2=0; i=0;
while(i<L){ c1=dv1.getUint8(i); if(haz[c1]) haz[c1].push(i); else haz[c1]=[i];  i++; }

(auto sorts all 1 byte matches by order they appear, cool)


test=haz[45]; //using byte 45 as a test for bytes in general

L2=test.length;

tst2=new Array(L2);

i=1; tst2[0]=test[0];
while(i!=L2){
 tst2[i]=test[i]^(test[i-1]);
 i++;
}


/*
start with byte 0, count only the lengths of each group of bytes equal to 0,
like dns domain format, but use length indicator of any number of bytes with bit 0 being reserved for indicating weather there are more bytes in the length indicator, if the length is greater than 128, then the first bit in the first byte would be set to 1, with the length number made of 14 bits across the two bytes excluding the fist bit of the 2nd byte also,
*/


//saaaasss function finds one factor at a time of any integer that can be accurately stored in javascript, returns false on failure or if input number (bign) is prime:

function old_sass(bign,lim){
 var e=Math.log(bign),e2; lim=lim||9001;
 while(lim--){
 e2=bign/e; if(!(e2%1)) break;
 e=Math.ceil(e2);
 }
 console.log("sass level is :"+lim);
 return lim?[e,e2]:false;
}


function sass(bign,lim){
 var L0=Math.log(bign),e=Math.ceil(L0),e2,flo; lim=lim||9001;
 while(lim--){
 e2=bign%e;
 if(e2==1&&(!flo)){flo=!0; e2=Math.floor(L0); }else
 if(!e2) break;
 e=e2;
 }
 console.log("sass level is :"+lim);
 return lim?e:false;
}


function sass2(bign,lim){
 var L0=Math.log2(bign),e=Math.ceil(L0),e2,flo; lim=lim||9001;
 while(lim--){
 e2=bign%e;
 if(e2==1&&(!flo)){flo=!0; e2=Math.floor(L0); }else
 if(!e2) break;
 e=e2;
 }
 console.log("sass level is :"+lim);
 return lim?e:false;
}



function factorize(bign,lim){
 var L0,e=1,e2=0,flo,f=[]; lim=lim||9001;
 while(lim--){
 if(e2===0){ f.push(e); bign/=e; L0=Math.log2(bign); e=Math.ceil(L0); flo=!1; }

 e2=bign%e;
 if(e2==1){ if(!flo){flo=!0; e2=Math.floor(L0); }else{ break; } }
  if(e2!=0) e=e2;

 }

 return lim?f:false;
}



cant=function(s){ if(typeof s!="string")s=""; var bg=BigInt(0),i=0,L=s.length,e8=BigInt(8); while(i!=L){ bg=(bg<<e8)+BigInt(s.charCodeAt(i)); i++; } return bg; }
//decimal places  Math.ceil(Math.log10())


//breakout (taken out)


self.ui161=new Uint16Array(ui8_1.buffer);

self.ui8_2=new Uint8Array(16);

self.i1=0; self.L=16;

while(i1<L){ ui8_2[i1]=ui8_1[i1]^ui8_1[16+i1]; i1++;}




self.i1=0;
self.xorL=0; self.nL1=0; self.xorL2=0;
 self.chc=new Uint16Array(153);  //change of change
while(i1!=L){
  nL0=xorL;   xorL^=ui161[i1];
  nL1=xorL2; xorL2=xorL^nL0;
  chc[i1]^=xorL2;
  i1++; }

*/

self.chamt=function ChangeAmount(xor){
  var _0=1,_1=2,_2=4,_3=8,_4=16,_5=32,_6=64,_7=128,_8=256,_9=512,_A=1024,_B=2048,_C=4096,_D=8192,_E=16384,_F=32768;

  return ((xor&_0)&&1)+((xor&_1)&&1)+((xor&_2)&&1)+((xor&_3)&&1)+((xor&_4)&&1)+((xor&_5)&&1)+((xor&_6)&&1)+((xor&_7)&&1)+((xor&_8)&&1)+((xor&_9)&&1)+((xor&_A)&&1)+((xor&_B)&&1)+((xor&_C)&&1)+((xor&_D)&&1)+((xor&_E)&&1)+((xor&_F)&&1);
};


self.cocam=function ChangeOfChangeAmount(xor){
  var _1=1,i=0,L=16,rez=0,lst=0,cur;
  while(i!=L){ cur=(xor&_1)&&1; rez+=cur&lst; lst=cur; _1<<=1; i++; }
  return rez;
};



/*
L=16; i=0;

ui163=new Uint16Array(16);

while(i!=L){ ui162[i]=chamt(ui161[i+0]^ui161[i+1+0]); ui163[i]=cocam(ui161[i+0]^ui161[i+1+0]);  i++; }
*/

function Btrring(ui16,bufr){
L=bufr.length; i=0; st=0; a=0; b=0; bi=0;

a=ui16[0]; b=ui16[1];

while(i!=L){
 bufr[bi+si]=ui16[i]^(((a<<st)&65535)+(b>>(16-st)));
 st++;
 if(st==16){i++; st=0; a=b; b=ui16[(i+1)%L]; }
}

}



function binAnTest(){

ctx.moveTo(0,250);
var val=250; bi=0; bit=0;
aam=128; chr=ui8_1[0]; i=0;

while(i<ui8_1.length){
 bit=(aam&chr)&&1;
 if(bit==lal){ if(bit==1) val--; else val++; }
 ctx.lineTo(bi,val);
 lal=bit;
 aam>>=1; bi++; if(aam==0){ aam=128; i++;  chr=ui8_1[i]; }
}

ctx.stroke();

}



//redo?
var i=16, a16=new Uint16Array(16), s=1; while(i--){ a16[i]=s; s<<=1; }
//look for patterns in bits, ring theory, winding?

//we're skip counting (the cumulative index of the NEXT BIT) now, by function: +1, +2, +3, (up to +16);  fib: 1,1,2,3,5,8,13,21,34,55;  fib: 1,3,4,7,11,18,29,47; etc; mult: *2, *3, *4, *5, *6 *7, etc; multi_fib: 2,3,6,18,108,1944,etc;etc; pow: ^2, ^3, ^4, ^5, ^6, ^7, ^8, ^9, ^10; other functions ?


//aka put the current BIT index into the function currently being used to scan for matches

//BIGfactor: factor the entire number and compress by counting repeated factors, might use modulus also,

//subtract number modulusing in multiples of two to save proccesor cycles? aka %7 as rep -(7*1024) = -(7<<10), then count down -(7<<9), -(7<<8) etc.

//limit to 16 megabyte length blocks for easier indexing? (3 byte index)

//find prime
function sheez(lol,upL){ lol=lol||33; upL=upL||(1<<24);
 var prm=[3,5,7,11,13,17,19,23,29,31],pL=10,pi=pL,g0=1;
  if(lol<33)lol=33; if(upL<33) return prm;
  while(lol<upL){
   pi--;
   g0=((lol%prm[pi])!=0)&&g0;
   if(pi==0){ if(g0) prm.push(lol); lol+=2;  pi=prm.length; g0=1; }
  }
  prm.unshift(2);
  return prm;
}