Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

panic: kernel segmentation violation. core dumped (only kidding)


devel / comp.compression / Re: One Way To Output LZ77 codes

SubjectAuthor
* Re: One Way To Output LZ77 codesHarry Potter
`* Re: One Way To Output LZ77 codesGerald R. Tamayo
 `* Re: One Way To Output LZ77 codesHarry Potter
  `* Re: One Way To Output LZ77 codesGerald R. Tamayo
   `* Re: One Way To Output LZ77 codesGerald R. Tamayo
    `* Re: One Way To Output LZ77 codesGerald R. Tamayo
     `* Re: One Way To Output LZ77 codesHarry Potter
      `- Re: One Way To Output LZ77 codesHarry Potter

1
Re: One Way To Output LZ77 codes

<f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=118&group=comp.compression#118

 copy link   Newsgroups: comp.compression
X-Received: by 2002:a37:b4d:: with SMTP id 74mr4421133qkl.92.1630606672044;
Thu, 02 Sep 2021 11:17:52 -0700 (PDT)
X-Received: by 2002:a25:6705:: with SMTP id b5mr6267841ybc.116.1630606669741;
Thu, 02 Sep 2021 11:17:49 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.compression
Date: Thu, 2 Sep 2021 11:17:49 -0700 (PDT)
In-Reply-To: <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=100.2.132.12; posting-account=xRocggoAAACFej4w6sQauoZjUP9yroE5
NNTP-Posting-Host: 100.2.132.12
References: <b5e3ca3e-579f-4d17-b598-d759e2f416ee@googlegroups.com>
<c1cbbfcb-3f5e-474a-9627-4369ca4dbf9dn@googlegroups.com> <601398a4-d579-4bf0-99e9-af3bf0ca4752n@googlegroups.com>
<67b9ba67-c9fc-4231-b231-2859110197aen@googlegroups.com> <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com>
Subject: Re: One Way To Output LZ77 codes
From: rose.jos...@yahoo.com (Harry Potter)
Injection-Date: Thu, 02 Sep 2021 18:17:52 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 24
 by: Harry Potter - Thu, 2 Sep 2021 18:17 UTC

On Wednesday, March 17, 2021 at 5:45:28 AM UTC-4, Gerald R. Tamayo wrote:
> Perhaps this simple illustration will help:
>
>
> Reduced Length LZ (RLLZ)
> (A very compact LZ. Made possible by deferred literals output.)
>
> aacbbdeaabb <- input source
> 012345678910 <- index
>
> encode all strings first:
>
> (size of string, string, number of occurrences of strings), [positions in file or block]
>
> aa: (2, aa, 2), [0, 7]
> bb: (2, bb, 2), [3, 9]
>
> encode literals last: [cde]
>
> Decompress:
>
> Decode all strings first;
> Decode literals.
> (The strings and literals are nicely in their correct order or sequences.)
I did that then some performance optimizations and am doing *worse* than without your technique. Maybe I'm doing something wrong. I need to try it again. :)

Re: One Way To Output LZ77 codes

<277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=199&group=comp.compression#199

 copy link   Newsgroups: comp.compression
X-Received: by 2002:a37:43c6:: with SMTP id q189mr2448566qka.315.1633180757617;
Sat, 02 Oct 2021 06:19:17 -0700 (PDT)
X-Received: by 2002:a25:69c7:: with SMTP id e190mr2351113ybc.334.1633180757314;
Sat, 02 Oct 2021 06:19:17 -0700 (PDT)
Path: rocksolid2!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.compression
Date: Sat, 2 Oct 2021 06:19:17 -0700 (PDT)
In-Reply-To: <f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2001:4450:833c:a500:19f1:e60e:c58e:e54e;
posting-account=x4y9KQoAAAAgtc4BPWDOKB7Ls5RAV5pf
NNTP-Posting-Host: 2001:4450:833c:a500:19f1:e60e:c58e:e54e
References: <b5e3ca3e-579f-4d17-b598-d759e2f416ee@googlegroups.com>
<c1cbbfcb-3f5e-474a-9627-4369ca4dbf9dn@googlegroups.com> <601398a4-d579-4bf0-99e9-af3bf0ca4752n@googlegroups.com>
<67b9ba67-c9fc-4231-b231-2859110197aen@googlegroups.com> <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
<f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>
Subject: Re: One Way To Output LZ77 codes
From: com...@gmail.com (Gerald R. Tamayo)
Injection-Date: Sat, 02 Oct 2021 13:19:17 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 35
 by: Gerald R. Tamayo - Sat, 2 Oct 2021 13:19 UTC

> I did that then some performance optimizations and am doing *worse* than without your technique. Maybe I'm doing something wrong. I need to try it again. :)

Maybe the following improved example will help.

Here is simple illustration for RLLZ, to be complete:

Reduced Length LZ (RLLZ)
(A very compact LZ. Made possible by deferred literals output.)

aacbcdeaabc <- input source
012345678910 <- index

Compress:

Encode all duplicated strings first:
Very simple:
(<size of string>, <string>, <number of "next" occurrences of string>), [positions in file or block (no match lengths needed)]

aa: (2, aa, 1), [0, 7]
bc: (2, bc, 1), [3, 9]

Better:
aa: (2, aa, 1-1=0), [0, 7]
bc: (2, bc, 1-1=0), [3, 9]

Encode literals last: [cde]

Decompress:

Decode all strings first;
Read/Get literals. (The literals are then inserted into the holes. Whatever the size of those holes randomly positioned in the write buffer, they are filled by the literals.)

The strings and literals are nicely in their correct order or sequences. Write to actual file.

Re: One Way To Output LZ77 codes

<4ca96552-407b-48d1-aefc-020be27e6bban@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=200&group=comp.compression#200

 copy link   Newsgroups: comp.compression
X-Received: by 2002:a0c:c189:: with SMTP id n9mr15217561qvh.5.1633183814415;
Sat, 02 Oct 2021 07:10:14 -0700 (PDT)
X-Received: by 2002:a25:bb0b:: with SMTP id z11mr4000149ybg.108.1633183814063;
Sat, 02 Oct 2021 07:10:14 -0700 (PDT)
Path: rocksolid2!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.compression
Date: Sat, 2 Oct 2021 07:10:13 -0700 (PDT)
In-Reply-To: <277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=100.2.132.12; posting-account=xRocggoAAACFej4w6sQauoZjUP9yroE5
NNTP-Posting-Host: 100.2.132.12
References: <b5e3ca3e-579f-4d17-b598-d759e2f416ee@googlegroups.com>
<c1cbbfcb-3f5e-474a-9627-4369ca4dbf9dn@googlegroups.com> <601398a4-d579-4bf0-99e9-af3bf0ca4752n@googlegroups.com>
<67b9ba67-c9fc-4231-b231-2859110197aen@googlegroups.com> <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
<f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com> <277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <4ca96552-407b-48d1-aefc-020be27e6bban@googlegroups.com>
Subject: Re: One Way To Output LZ77 codes
From: rose.jos...@yahoo.com (Harry Potter)
Injection-Date: Sat, 02 Oct 2021 14:10:14 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 234
 by: Harry Potter - Sat, 2 Oct 2021 14:10 UTC

Maybe there's a problem with my code. (?) I pasted the relevant code here. It uses Assembler, but I believe the original C code is still in the file.
--------------------------------
void CompBin01 (void)
{ //signed char c2; //Holds value for len. current
// int c2;
// unsigned /*j1,*/ j3, j4, j5;
// unsigned i, j, j2, k, m, n, o=0;
//vz.InPos=0;
k=0; vz.InPos=0;
for (; vz.InPos<vz.InEnd; )
{
//printc ('.');
printu (vz.InPos); printcr ();
/* if (Buffer2[vz.InPos>>3]&(1<<(vz.InPos&7))) {
//getkey ();
for (i=j=m=0; i<NumRLLZEnt; ++i) {
if (RLLZBuf[i].len>j && !memcmp(&InBuffer[vz.InPos], &InBuffer[RLLZBuf[i].loc], RLLZBuf[i].len)) {
j=RLLZBuf[i].len; m=i;
}
}
//if (j==0) {CompBin01U (); ++vz.InPos; continue;}
if (j==0) {WriteB (InBuffer[vz.InPos]); ++vz.InPos; continue;}
//CompBin01Ue ();
++backcol;
vz.InPos+=j;
} else {
//CompBin01U (); ++vz.InPos;
WriteB (InBuffer[vz.InPos]); ++vz.InPos;
}*/
//if (!(Buffer2[vz.InPos>>3]&(1<<(vz.InPos&7)))) WriteB (InBuffer[vz.InPos]);
//else ++backcol;
// if (!(Buffer2[vz.InPos>>3]&(1<<(vz.InPos&7)))) {
// WriteB (InBuffer[vz.InPos]);
// //++backcol;
// }
// ++vz.InPos;
if ((Buffer2[vz.InPos>>3]&(1<<(vz.InPos&7)))) {
//CompBin01Ue ();
writebuffer ();
for (; Buffer2[vz.InPos>>3]&(1<<(vz.InPos&7)); ++vz.InPos);
//++backcol;
} else {
CompBin01U ();
++vz.InPos;
}
}
writeoutlast ();
} static unsigned p;

void GetRLLZBlocks (void)
{ unsigned i, j, k, l, m, n, o;
unsigned q;
struct RLLZBuf* r;
for (i=NumRLLZEnt=0; i<vz.InEnd; ) {
printu (i); printcr ();
if ((lenc=GetLZW (i))>=4) {
o=techLZW.pos-(unsigned)&InBuffer;
//if (GetLZW(i+1)>=lenc+1) {++i; continue;}
for (j=0; j<NumRLLZEnt; ++j) {
if (RLLZBuf[j].len==lenc &&
!memcmp (&InBuffer[o], &InBuffer[RLLZBuf[j].loc], RLLZBuf[j].len))
break;
}
if (j==NumRLLZEnt) {
if (NumRLLZEnt>=1000) {
//++backcol;
++i; continue;
}
RLLZBuf[j].loc=o;
RLLZBuf[j].len=lenc;
for (k=0; k<lenc; k++) {
//Buffer3[(o+k)>>3]|=1<<(o+k&7);
}
RLLZBuf[j].numoccur=1;
++NumRLLZEnt;
}
++RLLZBuf[j].numoccur;
for (k=0; k<lenc; k++) {
//++backcol;
//Buffer3[(i+k)>>3]|=1<<(i+k&7);
}
i+=techLZW.size;
} else {
a: ++i;
}
}
for (i=0; i<NumRLLZEnt; ++i) {
//++backcol;
if (RLLZBuf[i].numoccur<5-(RLLZBuf[i].len>=5?2:0)) {
for (j=i; j<NumRLLZEnt; ++j) {
memcpy (&RLLZBuf[j], &RLLZBuf[j+1], sizeof (RLLZBuf[0]));
} --NumRLLZEnt; --i;
}
}
prints ("rllz="); printu (NumRLLZEnt); printcr (); getkey ();
WriteDist (NumRLLZEnt, 1024);
for (o=0; o<NumRLLZEnt; ++o) {
i=2;
lenc=RLLZBuf[o].len;
if (lenc<6) {
WriteDist (lenc-2+1-i, 6-i);
} else if (lenc< 11) {
WriteDist (0, 6-i);
//writeoutf_10 ();
WriteDist (lenc-6, 11-6);
} else if (lenc<18) {
WriteDist (5-i, 6-i);
//writeoutf_10 ();
WriteDist ((lenc- 11), (22- 11));
} else {
WriteDist (5-i, 6-i);
WriteDist ((18- 11)+(lenc-18)%4, (22- 11));
//writeoutf_01 ();
//WriteDist (11-7+((lenc-11)&5), 17-7);
WriteDist ((lenc-18)/4, (38-18+3)/4);
//WriteDist ((lenc-18), (57-18));
}
for (j=0; j<lenc; ++j) {
WriteB (InBuffer[RLLZBuf[o].loc+j]);
} k=0; m=-1;

for (l=n=0; l<vz.InEnd; )
{
//++backcol;
lenc=0; p=-1;
//if (Buffer2[vz.InPos>>3]&(1<<(vz.InPos&7))) {
//if (GetLZW(l)>=4) {
//if (!(Buffer3[l]>>(l>>3)&1<<(i&7))) {++l; continue;}
//if (InBuffer[l]!=InBuffer)
//r=&RLLZBuf[0];
cin=&InBuffer[l];
/*for (j=0; j<NumRLLZEnt; ++j) {

if ((q=r->len)>lenc &&
*cin==InBuffer[i=r->loc] &&
//(Buffer3[l>>3]&1<<(l&7)) &&
memcmp2(&InBuffer[i], q))
{lenc=q; p=j;}
++r;
}*/
__asm__ (
"\tlda\t#0\n"
"\tsta\t_i\n"
//"\tlda\tNumRLLZEnt+1\n"
"\tsta\t_i+1\n"
"\tlda\t#<_RLLZBuf\n"
"\tsta\tptr2\n"
"\tlda\t#>_RLLZBuf\n"
"\tsta\tptr2+1\n"

// "\tlda\t_cin\n"
// "\tsta\tptr4\n"
// "\tlda\t_cin+1\n"
// "\tsta\tptr4+1\n"

"@lp1:\n"
"\tldy\t#2\n"
"\tlda\t_lenc\n"
"\tcmp\t(ptr2),y\n"
"\tbeq\t@skip\n"
"\tbcs\t@skip\n"
"\tlda\t#<_InBuffer\n"
"\tldy\t#0\n"
"\tclc\n"
"\tadc\t(ptr2),y\n"
"\tsta\tptr3\n"
"\tiny\n"
"\tlda\t#>_InBuffer\n"
"\tadc\t(ptr2),y\n"
"\tsta\tptr3+1\n"

"\tldy\t#0\n"
"\tlda\t(_cin),y\n"
"\tcmp\t(ptr3),y\n"
"\tbne\t@skip\n"

"\tldy\t#2\n"
"\tlda\t(ptr2),y\n"
"\ttax\n"
"\ttay\n"
"\tdey\n"
"@lp2:\n"
"\tlda\t(_cin),y\n"
"\tcmp\t(ptr3),y\n"
"\tbne\t@skip\n"
"\tdey\n"
"\tbne\t@lp2\n"

"\tlda\t_i\n"
"\tsta\t_p\n"
"\tlda\t_i+1\n"
"\tsta\t_p+1\n"
"\tstx\t_lenc\n"

"@skip:\n"
"\tlda\tptr2\n"
"\tclc\n"
"\tadc\t#8\n"
"\tsta\tptr2\n"
"\tbcc\t@skip2\n"
"\tinc\tptr2+1\n"
"@skip2:\n"
"\tinc\t_i\n"
"\tbne\t@skip3\n"
"\tinc\t_i+1\n"
"@skip3:\n"
"\tlda\t_i+1\n"
"\tcmp\t_NumRLLZEnt+1\n"
"\tbcc\t@lp1\n"
"\tlda\t_i\n"
"\tcmp\t_NumRLLZEnt\n"
"\tbcc\t@lp1\n"
);
if (lenc && p==o) {
//++backcol;
for (i=0; i<lenc; i++) {
Buffer2[(l+i)>>3]|=1<<(l+i&7);
//++backcol;
}
WriteDist (l-k, vz.InEnd-k+1);
//k=l; l+=lenc;
k=l+lenc; l+=lenc;
} else {
++l;
}
} WriteDist (vz.InEnd-k, vz.InEnd+1-k);
printu (o); printcr ();
}
//printf (">>> %X\n", &Buffer2); getkey ();
} --------------------------------
WriteDist() writes the information using as few bits as possible.

Re: One Way To Output LZ77 codes

<36d76732-2c42-45c5-8d1f-1cb061673ee9n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=201&group=comp.compression#201

 copy link   Newsgroups: comp.compression
X-Received: by 2002:a05:620a:409:: with SMTP id 9mr3077823qkp.76.1633190057524;
Sat, 02 Oct 2021 08:54:17 -0700 (PDT)
X-Received: by 2002:a25:54c5:: with SMTP id i188mr4558538ybb.304.1633190057239;
Sat, 02 Oct 2021 08:54:17 -0700 (PDT)
Path: rocksolid2!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.compression
Date: Sat, 2 Oct 2021 08:54:17 -0700 (PDT)
In-Reply-To: <4ca96552-407b-48d1-aefc-020be27e6bban@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2001:4450:833c:a500:19f1:e60e:c58e:e54e;
posting-account=x4y9KQoAAAAgtc4BPWDOKB7Ls5RAV5pf
NNTP-Posting-Host: 2001:4450:833c:a500:19f1:e60e:c58e:e54e
References: <b5e3ca3e-579f-4d17-b598-d759e2f416ee@googlegroups.com>
<c1cbbfcb-3f5e-474a-9627-4369ca4dbf9dn@googlegroups.com> <601398a4-d579-4bf0-99e9-af3bf0ca4752n@googlegroups.com>
<67b9ba67-c9fc-4231-b231-2859110197aen@googlegroups.com> <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
<f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com> <277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>
<4ca96552-407b-48d1-aefc-020be27e6bban@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <36d76732-2c42-45c5-8d1f-1cb061673ee9n@googlegroups.com>
Subject: Re: One Way To Output LZ77 codes
From: com...@gmail.com (Gerald R. Tamayo)
Injection-Date: Sat, 02 Oct 2021 15:54:17 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 34
 by: Gerald R. Tamayo - Sat, 2 Oct 2021 15:54 UTC

Maybe the following improved example will help.

Here is simple illustration for RLLZ, to be complete:

Reduced Length LZ (RLLZ)
(A very compact LZ. Made possible by deferred literals output.)

aacbcdeaabc <- input source
012345678910 <- index

Compress:

Encode all duplicated strings first:
Very simple:
(<size of string>, <string>, <number of "next" occurrences of string>), [positions in file or block (no match lengths needed)],
:

aa: (2, aa, 1), [0, 7]
bc: (2, bc, 1), [3, 9]

Better:
aa: (2, aa, 1-1=0), [0, 7]
bc: (2, bc, 1-1=0), [3, 9]

Encode end of string code stream: (0, , );

Encode literals last: [cde].

Decompress:

Decode all strings first;
Read/Get literals. (The literals are then inserted into the holes. Whatever the size of those holes randomly positioned in the write buffer, they are filled by the literals.)

The strings and literals are nicely in their correct order or sequences. Write to actual file.

Re: One Way To Output LZ77 codes

<25dc0157-ab63-42b4-9149-1bb2314615can@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=374&group=comp.compression#374

 copy link   Newsgroups: comp.compression
X-Received: by 2002:ac8:56e2:0:b0:3bf:ae79:92a3 with SMTP id 2-20020ac856e2000000b003bfae7992a3mr4650223qtu.8.1678217303308;
Tue, 07 Mar 2023 11:28:23 -0800 (PST)
X-Received: by 2002:a05:622a:4299:b0:3bf:f94e:70ff with SMTP id
cr25-20020a05622a429900b003bff94e70ffmr6261731qtb.6.1678217303070; Tue, 07
Mar 2023 11:28:23 -0800 (PST)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.compression
Date: Tue, 7 Mar 2023 11:28:22 -0800 (PST)
In-Reply-To: <36d76732-2c42-45c5-8d1f-1cb061673ee9n@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2001:4450:83ec:8800:4958:6d80:9386:73ab;
posting-account=x4y9KQoAAAAgtc4BPWDOKB7Ls5RAV5pf
NNTP-Posting-Host: 2001:4450:83ec:8800:4958:6d80:9386:73ab
References: <b5e3ca3e-579f-4d17-b598-d759e2f416ee@googlegroups.com>
<c1cbbfcb-3f5e-474a-9627-4369ca4dbf9dn@googlegroups.com> <601398a4-d579-4bf0-99e9-af3bf0ca4752n@googlegroups.com>
<67b9ba67-c9fc-4231-b231-2859110197aen@googlegroups.com> <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
<f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com> <277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>
<4ca96552-407b-48d1-aefc-020be27e6bban@googlegroups.com> <36d76732-2c42-45c5-8d1f-1cb061673ee9n@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <25dc0157-ab63-42b4-9149-1bb2314615can@googlegroups.com>
Subject: Re: One Way To Output LZ77 codes
From: com...@gmail.com (Gerald R. Tamayo)
Injection-Date: Tue, 07 Mar 2023 19:28:23 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 3056
 by: Gerald R. Tamayo - Tue, 7 Mar 2023 19:28 UTC

On Saturday, October 2, 2021 at 11:54:18 PM UTC+8, Gerald R. Tamayo wrote:
> Maybe the following improved example will help.
>
> Here is simple illustration for RLLZ, to be complete:
> Reduced Length LZ (RLLZ)
> (A very compact LZ. Made possible by deferred literals output.)
> aacbcdeaabc <- input source
> 012345678910 <- index
>
> Compress:
>
> Encode all duplicated strings first:
> Very simple:
> (<size of string>, <string>, <number of "next" occurrences of string>), [positions in file or block (no match lengths needed)],
> :
>
> aa: (2, aa, 1), [0, 7]
> bc: (2, bc, 1), [3, 9]
>
> Better:
> aa: (2, aa, 1-1=0), [0, 7]
> bc: (2, bc, 1-1=0), [3, 9]
>
> Encode end of string code stream: (0, , );
>
> Encode literals last: [cde].
> Decompress:
>
> Decode all strings first;
> Read/Get literals. (The literals are then inserted into the holes. Whatever the size of those holes randomly positioned in the write buffer, they are filled by the literals.)
>
> The strings and literals are nicely in their correct order or sequences. Write to actual file.

"Deferred literals transmission" in Reduced Length LZ (#RLLZ) #algorithm actually has many practical uses in #data #compression! Not just in the way I described RLLZ.

Re: One Way To Output LZ77 codes

<2bebc7d8-2693-4587-8524-ed4985ae1967n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=375&group=comp.compression#375

 copy link   Newsgroups: comp.compression
X-Received: by 2002:ac8:530b:0:b0:3c0:1010:8d39 with SMTP id t11-20020ac8530b000000b003c010108d39mr5422951qtn.2.1678223401603;
Tue, 07 Mar 2023 13:10:01 -0800 (PST)
X-Received: by 2002:ac8:4611:0:b0:3b7:fda5:1cc4 with SMTP id
p17-20020ac84611000000b003b7fda51cc4mr3221668qtn.13.1678223401370; Tue, 07
Mar 2023 13:10:01 -0800 (PST)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.compression
Date: Tue, 7 Mar 2023 13:10:01 -0800 (PST)
In-Reply-To: <25dc0157-ab63-42b4-9149-1bb2314615can@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2001:4450:83ec:8800:4958:6d80:9386:73ab;
posting-account=x4y9KQoAAAAgtc4BPWDOKB7Ls5RAV5pf
NNTP-Posting-Host: 2001:4450:83ec:8800:4958:6d80:9386:73ab
References: <b5e3ca3e-579f-4d17-b598-d759e2f416ee@googlegroups.com>
<c1cbbfcb-3f5e-474a-9627-4369ca4dbf9dn@googlegroups.com> <601398a4-d579-4bf0-99e9-af3bf0ca4752n@googlegroups.com>
<67b9ba67-c9fc-4231-b231-2859110197aen@googlegroups.com> <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
<f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com> <277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>
<4ca96552-407b-48d1-aefc-020be27e6bban@googlegroups.com> <36d76732-2c42-45c5-8d1f-1cb061673ee9n@googlegroups.com>
<25dc0157-ab63-42b4-9149-1bb2314615can@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <2bebc7d8-2693-4587-8524-ed4985ae1967n@googlegroups.com>
Subject: Re: One Way To Output LZ77 codes
From: com...@gmail.com (Gerald R. Tamayo)
Injection-Date: Tue, 07 Mar 2023 21:10:01 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Gerald R. Tamayo - Tue, 7 Mar 2023 21:10 UTC

> "Deferred literals transmission" in Reduced Length LZ (#RLLZ) #algorithm actually has many practical uses in #data #compression! Not just in the way I described RLLZ.

You can use "deferred literals transmission" if you want. Permission granted, no strings attached. ;)

Re: One Way To Output LZ77 codes

<20a91ec9-88d0-4594-92a4-b9bf1d852e46n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=376&group=comp.compression#376

 copy link   Newsgroups: comp.compression
X-Received: by 2002:a05:620a:1525:b0:742:6f50:2444 with SMTP id n5-20020a05620a152500b007426f502444mr4591092qkk.13.1678224185396;
Tue, 07 Mar 2023 13:23:05 -0800 (PST)
X-Received: by 2002:a05:620a:2154:b0:73b:aa08:79ea with SMTP id
m20-20020a05620a215400b0073baa0879eamr3563642qkm.5.1678224185151; Tue, 07 Mar
2023 13:23:05 -0800 (PST)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.compression
Date: Tue, 7 Mar 2023 13:23:04 -0800 (PST)
In-Reply-To: <2bebc7d8-2693-4587-8524-ed4985ae1967n@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=74.108.229.93; posting-account=xRocggoAAACFej4w6sQauoZjUP9yroE5
NNTP-Posting-Host: 74.108.229.93
References: <b5e3ca3e-579f-4d17-b598-d759e2f416ee@googlegroups.com>
<c1cbbfcb-3f5e-474a-9627-4369ca4dbf9dn@googlegroups.com> <601398a4-d579-4bf0-99e9-af3bf0ca4752n@googlegroups.com>
<67b9ba67-c9fc-4231-b231-2859110197aen@googlegroups.com> <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
<f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com> <277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>
<4ca96552-407b-48d1-aefc-020be27e6bban@googlegroups.com> <36d76732-2c42-45c5-8d1f-1cb061673ee9n@googlegroups.com>
<25dc0157-ab63-42b4-9149-1bb2314615can@googlegroups.com> <2bebc7d8-2693-4587-8524-ed4985ae1967n@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <20a91ec9-88d0-4594-92a4-b9bf1d852e46n@googlegroups.com>
Subject: Re: One Way To Output LZ77 codes
From: rose.jos...@yahoo.com (Harry Potter)
Injection-Date: Tue, 07 Mar 2023 21:23:05 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 1839
 by: Harry Potter - Tue, 7 Mar 2023 21:23 UTC

I want to implement this on small 8-bit and 16-bit platforms where I might not have enough memory to store a whole file. Is there

Re: One Way To Output LZ77 codes

<c1c89a9a-e3bb-479e-94fe-6cc5ffd9db6cn@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=377&group=comp.compression#377

 copy link   Newsgroups: comp.compression
X-Received: by 2002:ae9:eb4e:0:b0:71f:b908:7b7e with SMTP id b75-20020ae9eb4e000000b0071fb9087b7emr3955173qkg.10.1678224301717;
Tue, 07 Mar 2023 13:25:01 -0800 (PST)
X-Received: by 2002:a05:6214:4a5c:b0:56f:fe44:f257 with SMTP id
ph28-20020a0562144a5c00b0056ffe44f257mr4300364qvb.1.1678224301538; Tue, 07
Mar 2023 13:25:01 -0800 (PST)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.compression
Date: Tue, 7 Mar 2023 13:25:01 -0800 (PST)
In-Reply-To: <20a91ec9-88d0-4594-92a4-b9bf1d852e46n@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=74.108.229.93; posting-account=xRocggoAAACFej4w6sQauoZjUP9yroE5
NNTP-Posting-Host: 74.108.229.93
References: <b5e3ca3e-579f-4d17-b598-d759e2f416ee@googlegroups.com>
<c1cbbfcb-3f5e-474a-9627-4369ca4dbf9dn@googlegroups.com> <601398a4-d579-4bf0-99e9-af3bf0ca4752n@googlegroups.com>
<67b9ba67-c9fc-4231-b231-2859110197aen@googlegroups.com> <3be433da-97c4-45d2-991d-53b32d6bce1an@googlegroups.com>
<f96ad285-5493-4fb6-9414-55ca9486cf0an@googlegroups.com> <277eaa59-fd4e-4837-8ce5-8e278fd5e379n@googlegroups.com>
<4ca96552-407b-48d1-aefc-020be27e6bban@googlegroups.com> <36d76732-2c42-45c5-8d1f-1cb061673ee9n@googlegroups.com>
<25dc0157-ab63-42b4-9149-1bb2314615can@googlegroups.com> <2bebc7d8-2693-4587-8524-ed4985ae1967n@googlegroups.com>
<20a91ec9-88d0-4594-92a4-b9bf1d852e46n@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <c1c89a9a-e3bb-479e-94fe-6cc5ffd9db6cn@googlegroups.com>
Subject: Re: One Way To Output LZ77 codes
From: rose.jos...@yahoo.com (Harry Potter)
Injection-Date: Tue, 07 Mar 2023 21:25:01 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 2084
 by: Harry Potter - Tue, 7 Mar 2023 21:25 UTC

I want to implement this on small 8-bit and 16-bit platforms where I might not have enough memory to store a whole file. Is there a way to get this to work only on a piece of a file? Or maight I have to divide the file into smaller pieces?

BTW, sorry about the last, incomplete post. I pressed the wrong key. :(

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor