Thread: loseless data compression method for all digital data type

1. @pacalovasjurijus
Then try to develop/write your method/algorithm.
Most importantly, test your software on random+incompressible files and posts REAL results (benchmark) here.
Finally, share your software with us.

Of course, you posted one "working" compressor that contains GUI and which I tested it on SHARND. Unfortunately, your method does not work in a way you claiming that. It only creates unnamed file with .zip extension. All files are only stored, they isn´t compressed - precisely, AMilionRandomDigits was compressed below 50%, but goal of this challenge is to compress AMillionRandomDigits.bin or .txt alongside the size of your compressor and it must be smaller than AMillionRandomDigits.bin.

Ah, you said that you don´t have resources to developing softwares? It´s possible to convert python script to standalone software using youtube tutorials. Conversion is pretty straightforward. Try this, post software here and we can test your algorithm and see if you´re able to compress even pure random content such as SHARND. That could help you to determine where you are in terms of compression.

I won´t saying that it´s impossible to compress random data, I´m saying YOUR method does not work as you claimed.

2. Spring 1.0.0.3
Speed 40 KB/s
Compress random files and compression files and just one time and not compress usable files.

3. Spring 1.0.0.3

import os
from multiprocessing import Pool,Value

def f(x):

return 16383**(x+1)

if __name__ == '__main__':
pool = Pool(processes=4)               # start 4 worker processes
#result = pool.apply_async(f, [147456])     # evaluate "f(10)" asynchronously
#print(result.get(timeout=1))           # prints "100" unless your computer is *very* slow
#print(pool.map(f, range(147456)))          # prints "[0, 1, 4,..., 81]"

import binascii
import json

szxz=""
lenfa=0
block=1
blockw=0
blockw1=1
virationc=1
asqw=0
bitc=32
lenf1=0
a=0
qfl=0
h=0
byteb=""
notexist=""
lenf=0
dd=0
numberschangenotexistq = []
qwa=0
z=0
m = []
p=0
asd=""
b=0
szx=""
asf2="0b"
while b<blockw1:
m+=[-1]
b=b+1
k = []
wer=""
numberschangenotexist = []
numbers = []
name = input("What is name of file? ")
namea="file.Spring"
namem=name+"+"
s=""
qwt=""
sda=""
ert=0
aqwer=0
aqwq=0
aqwers=0
qwaw=""
zxvbf=0

with open(namea, "w") as f4:
f4.write(s)
with open(namea, "a") as f3:
f3.write(namem)
with open(name, "rb") as binary_file:
lenf1=len(data)

if lenf1<100:
print("This file is too small");
raise SystemExit
s=str(data)
lenf=len(data)
while dd<1:

zxvbf=0
szxz=""
lenfa=0
a=0
qfl=0
h=0
byteb=""
notexist=""
lenf=0

numberschangenotexistq = []

z=0
m = []
p=0
asd=""
b=0
szx=""
asf2="0b"
while b<blockw1:
m+=[-1]
b=b+1
k = []
wer=""
numberschangenotexist = []
numbers = []
s=""
qwt=""
ert=0
aqwer=0
aqwq=0
aqwers=0
qwaw=""
dd=dd+1
szx=""
asqw=0

sda=bin(int(binascii.hexlify(data),16))[2:]

lenf=len(sda)
xc=8-lenf%8
z=0
if xc!=0:
if xc!=8:
while z<xc:
szx="0"+szx
z=z+1
sda=szx+sda
lenf=len(sda)
szx=""

for byte in sda:
aqwer=aqwer+1
aqwers=aqwers+1
qwaw=qwaw+byte

if aqwer<=bitc:
qwt=qwt+byte
if aqwer==bitc:
aqwq=int(qwt,2)
qwt=""
a=a+1
h=h+1
asqw=asqw+1

av=bin(aqwq)
if a<=block and aqwer==bitc:
aqwer=0

if a == block:

p=0

b=-1
kl=blockw
cb=0
er=-1
ghj=0
ghjd=1
bnk=1
p=0
cvz=0
aqwqs=0
qwa=qwa+1
aqwqs=int(qwaw,2)
szxv=""
szxv=bin(asqw)[2:]
lenfqw=len(szxv)
szx=bin(aqwqs)[3:]
cvz=0
lenf=len(szx)
lenfb=len(szxv)

if aqwqs==0:
raise SystemExit

if lenf==31:
szx=bin(aqwqs)[4:]
lenf=len(szx)
xc=30-lenf%30
z=0

verty=0
if xc!=0:
if xc!=30:
while z<xc:
verty=verty+1
if verty==1:
szx="0"+szx
z=z+1
if verty>1:
szx="1"+szx
z=z+1
szx="11"+szx
wer=wer+szx

szx=""

if lenf==30:

szx=bin(aqwqs)[5:]
lenf=len(szx)
xc=29-lenf%29
z=0

verty=0
if xc!=0:
if xc!=29:
while z<xc:
verty=verty+1
if verty==1:
szx="0"+szx
z=z+1
if verty>1:
szx="1"+szx
z=z+1
szx="10"+szx
wer=wer+szx

szx=""

if lenf<=29:

xc=30-lenf
z=0

verty=0
if xc!=0:
if xc!=30:
while z<xc:
verty=verty+1
if verty==1:
szx="0"+szx
z=z+1
if verty>1:
szx="1"+szx
z=z+1
szx="0"+szx
wer=wer+szx

szx=""

a=0
numberschangenotexist = []
del k[:]
del numbers[:]
m = []
b=0
while b<blockw1:
m+=[-1]
b=b+1
b=0
qwaw=""

a=0
wer=wer+qwaw
qwaw=""
wer="1"+wer+"1"
lenf=len(wer)
xc=8-lenf%8
z=0

if xc!=0:
if xc!=8:
while z<xc:
szx="0"+szx
z=z+1
wer=wer+szx
lenf=len(szx)
szx=""

wer="0b"+wer
n = int(wer, 2)
jl=binascii.unhexlify('%x' % n)
data=jl
with open(namea, "ab") as f2ww:
f2ww.write(jl)



4. I study at TU Dublin and Need just to know python, c and Java

5. Originally Posted by pacalovasjurijus
Software and program Its the same because we don't have program.
A program is a set of instructions used to control the behavior of a machine “software”.
Computer software, or simply software, is a collection of data or computer instructions that tell the computer how to work. This is in contrast to physical hardware, from which the system is built and actually performs the work. In computer science and software engineering, computer software is all information processed by computer systems, programs and data. Computer software includes computer programs, libraries and related non-executable data, such as online documentation or digital media. Computer hardware and software require each other and neither can be realistically used on its own.
Software development

Software development
Core activities
Methodologies and frameworks
Supporting disciplines
Practices
Tools
Standards and Bodies of Knowledge
Glossaries
• v
• t
• e

Software development is the process of conceiving, specifying, designing, programming, documenting, testing, and bug fixing involved in creating and maintaining applications, frameworks, or other software components. Software development is a process of writing and maintaining the source code, but in a broader sense, it includes all that is involved between the conception of the desired software through to the final manifestation of the software, sometimes in a planned and structured process.[1] Therefore, software development may include research, new development, prototyping, modification, reuse, re-engineering, maintenance, or any other activities that result in software products.[2]
Software can be developed for a variety of purposes, the three most common being to meet specific needs of a specific client/business (the case with custom software), to meet a perceived need of some set of potential users (the case with commercial and open source software), or for personal use (e.g. a scientist may write software to automate a mundane task). Embedded software development, that is, the development of embedded software, such as used for controlling consumer products, requires the development process to be integrated with the development of the controlled physical product. System software underlies applications and the programming process itself, and is often developed separately.
The need for better quality control of the software development process has given rise to the discipline of software engineering, which aims to apply the systematic approach exemplified in the engineering paradigm to the process of software development.
There are many approaches to software project management, known as software development life cycle models, methodologies, processes, or models. The waterfall model is a traditional version, contrasted with the more recent innovation of agile software development.
Contents

Methodologies

A software development process (also known as a software development methodology, model, or life cycle) is a framework that is used to structure, plan, and control the process of developing information systems. A wide variety of such frameworks has evolved over the years, each with its own recognized strengths and weaknesses. There are several different approaches to software development: some take a more structured, engineering-based approach to develop business solutions, whereas others may take a more incremental approach, where software evolves as it is developed piece-by-piece. One system development methodology is not necessarily suitable for use by all projects. Each of the available methodologies is best suited to specific kinds of projects, based on various technical, organizational, project and team considerations.[3]
Most methodologies share some combination of the following stages of software development:

• Analyzing the problem
• Market research
• Gathering requirements for the proposed business solution
• Devising a plan or design for the software-based solution
• Implementation (coding) of the software
• Testing the software
• Deployment
• Maintenance and bug fixing

These stages are often referred to collectively as the software development life-cycle, or SDLC. Different approaches to software development may carry out these stages in different orders, or devote more or less time to different stages. The level of detail of the documentation produced at each stage of software development may also vary. These stages may also be carried out in turn (a “waterfall” based approach), or they may be repeated over various cycles or iterations (a more "extreme" approach). The more extreme approach usually involves less time spent on planning and documentation, and more time spent on coding and development of automated tests. More “extreme” approaches also promote continuous testing throughout the development life-cycle, as well as having a working (or bug-free) product at all times. More structured or “waterfall” based approaches attempt to assess the majority of risks and develop a detailed plan for the software before implementation (coding) begins, and avoid significant design changes and re-coding in later stages of the software development life-cycle planning.
There are significant advantages and disadvantages to the various methodologies, and the best approach to solving a problem using software will often depend on the type of problem. If the problem is well understood and a solution can be effectively planned out ahead of time, the more "waterfall" based approach may work the best. If, on the other hand, the problem is unique (at least to the development team) and the structure of the software solution cannot be easily envisioned, then a more "extreme" incremental approach may work best.
Software development activities

Identification of need

The sources of ideas for software products are plentiful. These ideas can come from market research including the demographics of potential new customers, existing customers, sales prospects who rejected the product, other internal software development staff, or a creative third party. Ideas for software products are usually first evaluated by marketing personnel for economic feasibility, for fit with existing channels distribution, for possible effects on existing product lines, required features, and for fit with the company's marketing objectives. In a marketing evaluation phase, the cost and time assumptions become evaluated. A decision is reached early in the first phase as to whether, based on the more detailed information generated by the marketing and development staff, the project should be pursued further.[4]
In the book "Great Software Debates", Alan M. Davis states in the chapter "Requirements", sub-chapter "The Missing Piece of Software Development"
Students of engineering learn engineering and are rarely exposed to finance or marketing. Students of marketing learn marketing and are rarely exposed to finance or engineering. Most of us become specialists in just one area. To complicate matters, few of us meet interdisciplinary people in the workforce, so there are few roles to mimic. Yet, software product planning is critical to the development success and absolutely requires knowledge of multiple disciplines.[5]
Because software development may involve compromising or going beyond what is required by the client, a software development project may stray into less technical concerns such as human resources, risk management, intellectual property, budgeting, crisis management, etc. These processes may also cause the role of business development to overlap with software development.
Planning

Planning is an objective of each and every activity, where we want to discover things that belong to the project. An important task in creating a software program is extracting the requirements or requirements analysis.[6] Customers typically have an abstract idea of what they want as an end result but do not know what software should do. Skilled and experienced software engineers recognize incomplete, ambiguous, or even contradictory requirements at this point. Frequently demonstrating live code may help reduce the risk that the requirements are incorrect.
"Although much effort is put in the requirements phase to ensure that requirements are complete and consistent, rarely that is the case; leaving the software design phase as the most influential one when it comes to minimizing the effects of new or changing requirements. Requirements volatility is challenging because they impact future or already going development efforts."[7]
Once the general requirements are gathered from the client, an analysis of the scope of the development should be determined and clearly stated. This is often called a scope document.
Designing

Main articles: Software design and Systems design
Once the requirements are established, the design of the software can be established in a software design document. This involves a preliminary or high-level design of the main modules with an overall picture (such as a block diagram) of how the parts fit together. The language, operating system, and hardware components should all be known at this time. Then a detailed or low-level design is created, perhaps with prototyping as proof-of-concept or to firm up requirements.
Implementation, testing and documenting

Implementation is the part of the process where software engineers actually program the code for the project.
Software testing is an integral and important phase of the software development process. This part of the process ensures that defects are recognized as soon as possible. In some processes, generally known as test-driven development, tests may be developed just before implementation and serve as a guide for the implementation's correctness.
Documenting the internal design of software for the purpose of future maintenance and enhancement is done throughout development. This may also include the writing of an API, be it external or internal. The software engineering process chosen by the developing team will determine how much internal documentation (if any) is necessary. Plan-driven models (e.g., Waterfall) generally produce more documentation than Agile models.
Deployment and maintenance

Deployment starts directly after the code is appropriately tested, approved for release, and sold or otherwise distributed into a production environment. This may involve installation, customization (such as by setting parameters to the customer's values), testing, and possibly an extended period of evaluation.[citation needed]
Software training and support is important, as software is only effective if it is used correctly.[citation needed]
Maintaining and enhancing software to cope with newly discovered faults or requirements can take substantial time and effort, as missed requirements may force redesign of the software.[citation needed]. In most cases maintenance is required on regular basis to fix reported issues and keep the software running.
Subtopics

View model

The TEAF Matrix of Views and Perspectives.

A view model is a framework that provides the viewpoints on the system and its environment, to be used in the software development process. It is a graphical representation of the underlying semantics of a view.
The purpose of viewpoints and views is to enable human engineers to comprehend very complex systems and to organize the elements of the problem and the solution around domains of expertise. In the engineering of physically intensive systems, viewpoints often correspond to capabilities and responsibilities within the engineering organization.[8]
Most complex system specifications are so extensive that no one individual can fully comprehend all aspects of the specifications. Furthermore, we all have different interests in a given system and different reasons for examining the system's specifications. A business executive will ask different questions of a system make-up than would a system implementer. The concept of viewpoints framework, therefore, is to provide separate viewpoints into the specification of a given complex system. These viewpoints each satisfy an audience with interest in some set of aspects of the system. Associated with each viewpoint is a viewpoint language that optimizes the vocabulary and presentation for the audience of that viewpoint.

Graphical representation of the current state of information provides a very effective means for presenting information to both users and system developers.

example of the interaction between business process and data models.[9]

• A business model illustrates the functions associated with the business process being modeled and the organizations that perform these functions. By depicting activities and information flows, a foundation is created to visualize, define, understand, and validate the nature of a process.
• A data model provides the details of information to be stored and is of primary use when the final product is the generation of computer software code for an application or the preparation of a functional specification to aid a computer software make-or-buy decision. See the figure on the right for an example of the interaction between business process and data models.[9]

Usually, a model is created after conducting an interview, referred to as business analysis. The interview consists of a facilitator asking a series of questions designed to extract required information that describes a process. The interviewer is called a facilitator to emphasize that it is the participants who provide the information. The facilitator should have some knowledge of the process of interest, but this is not as important as having a structured methodology by which the questions are asked of the process expert. The methodology is important because usually a team of facilitators is collecting information across the facility and the results of the information from all the interviewers must fit together once completed.[9]
The models are developed as defining either the current state of the process, in which case the final product is called the "as-is" snapshot model, or a collection of ideas of what the process should contain, resulting in a "what-can-be" model. Generation of process and data models can be used to determine if the existing processes and information systems are sound and only need minor modifications or enhancements, or if re-engineering is required as a corrective action. The creation of business models is more than a way to view or automate your information process. Analysis can be used to fundamentally reshape the way your business or organization conducts its operations.[9]
Computer-aided software engineering

Computer-aided software engineering (CASE), in the field software engineering, is the scientific application of a set of software tools and methods to the development of software which results in high-quality, defect-free, and maintainable software products.[10] It also refers to methods for the development of information systems together with automated tools that can be used in the software development process.[11] The term "computer-aided software engineering" (CASE) can refer to the software used for the automated development of systems software, i.e., computer code. The CASE functions include analysis, design, and programming. CASE tools automate methods for designing, documenting, and producing structured computer code in the desired programming language.[12]
Two key ideas of Computer-aided Software System Engineering (CASE) are:[13]

• Foster computer assistance in software development and software maintenance processes, and
• An engineering approach to software development and maintenance.

Typical CASE tools exist for configuration management, data modeling, model transformation, refactoring, source code generation.
Integrated development environment

Anjuta, a C and C++ IDE for the GNOME environment

An integrated development environment (IDE) also known as integrated design environment or integrated debugging environment is a software application that provides comprehensive facilities to computer programmers for software development. An IDE normally consists of a:

IDEs are designed to maximize programmer productivity by providing tight-knit components with similar user interfaces. Typically an IDE is dedicated to a specific programming language, so as to provide a feature set which most closely matches the programming paradigms of the language.
Modeling language

A modeling language is any artificial language that can be used to express information or knowledge or systems in a structure that is defined by a consistent set of rules. The rules are used for interpretation of the meaning of components in the structure. A modeling language can be graphical or textual.[14] Graphical modeling languages use a diagram techniques with named symbols that represent concepts and lines that connect the symbols and that represent relationships and various other graphical annotation to represent constraints. Textual modeling languages typically use standardised keywords accompanied by parameters to make computer-interpretable expressions.
Examples of graphical modelling languages in the field of software engineering are:

Not all modeling languages are executable, and for those that are, using them doesn't necessarily mean that programmers are no longer needed. On the contrary, executable modeling languages are intended to amplify the productivity of skilled programmers, so that they can address more difficult problems, such as parallel computing and distributed systems.

A programming paradigm is a fundamental style of computer programming, which is not generally dictated by the project management methodology (such as waterfall or agile). Paradigms differ in the concepts and abstractions used to represent the elements of a program (such as objects, functions, variables, constraints) and the steps that comprise a computation (such as assignations, evaluation, continuations, data flows). Sometimes the concepts asserted by the paradigm are utilized cooperatively in high-level system architecture design; in other cases, the programming paradigm's scope is limited to the internal structure of a particular program or module.
A programming language can support multiple paradigms. For example, programs written in C++ or Object Pascal can be purely procedural, or purely object-oriented, or contain elements of both paradigms. Software designers and programmers decide how to use those paradigm elements. In object-oriented programming, programmers can think of a program as a collection of interacting objects, while in functional programming a program can be thought of as a sequence of stateless function evaluations. When programming computers or systems with many processors, process-oriented programming allows programmers to think about applications as sets of concurrent processes acting upon logically shared data structures.
Just as different groups in software engineering advocate different methodologies, different programming languages advocate different programming paradigms. Some languages are designed to support one paradigm (Smalltalk supports object-oriented programming, Haskell supports functional programming), while other programming languages support multiple paradigms (such as Object Pascal, C++, C#, Visual Basic, Common Lisp, Scheme, Python, Ruby, and Oz).
Many programming paradigms are as well known for what methods they forbid as for what they enable. For instance, pure functional programming forbids using side-effects; structured programming forbids using goto statements. Partly for this reason, new paradigms are often regarded as doctrinaire or overly rigid by those accustomed to earlier styles.[citation needed] Avoiding certain methods can make it easier to prove theorems about a program's correctness, or simply to understand its behavior.

what´s the point of that? It´s garbage here!
Have you readed my prior post CAREFULLY?

6. 0000 0000 0000 0000 0000 0000 0000 0000
[]

1111 1111 1111 1111 1111 1111 1111 1111
1/111 1111 1111 1111 1111 1111 1111 1111
1/1/11 1111 1111 1111 1111 1111 1111 1111
11 11 1111 1111 1111 1111 1111 1111 111
11
11 1111 1111 1111 1111 1111 1111 111
11 1111 1111 1111 1111 1111 1111 111

0111 1111 1111 1111 1111 1111 1111 1111
1\11 1111 1111 1111 1111 1111 1111 1111
1\1 1111 1111 1111 1111 1111 1111 1111
10 1 1111 1111 1111 1111 1111 1111 1111
10
1 1111 1111 1111 1111 1111 1111 1111
01 11 1 1111 1111 1111 1111 1111 1111 1111

0011 1111 1111 1111 1111 1111 1111 1111
00\111111 1111 1111 1111 1111 1111 1111
0011111 1111 1111 1111 1111 1111 11
0 0
11
0011 1111 1111 1111 1111 1111 1111 1111



if aqwqs==0:
raise SystemExit

if lenf==31:
szx=bin(aqwqs)[4:]
lenf=len(szx)
xc=30-lenf%30
z=0

verty=0
if xc!=0:
if xc!=30:
while z<xc:
verty=verty+1
if verty==1:
szx="0"+szx
z=z+1
if verty>1:
szx="1"+szx
z=z+1
szx="11"+szx
wer=wer+szx

szx=""

if lenf==30:

szx=bin(aqwqs)[5:]
lenf=len(szx)
xc=29-lenf%29
z=0

verty=0
if xc!=0:
if xc!=29:
while z<xc:
verty=verty+1
if verty==1:
szx="0"+szx
z=z+1
if verty>1:
szx="1"+szx
z=z+1
szx="10"+szx
wer=wer+szx

szx=""

if lenf<=29:

xc=30-lenf
z=0

verty=0
if xc!=0:
if xc!=30:
while z<xc:
verty=verty+1
if verty==1:
szx="0"+szx
z=z+1
if verty>1:
szx="1"+szx
z=z+1
szx="0"+szx
wer=wer+szx

szx=""



7. Originally Posted by CompressMaster
@pacalovasjurijus
Then try to develop/write your method/algorithm.
Most importantly, test your software on random+incompressible files and posts REAL results (benchmark) here.
Finally, share your software with us.

Of course, you posted one "working" compressor that contains GUI and which I tested it on SHARND. Unfortunately, your method does not work in a way you claiming that. It only creates unnamed file with .zip extension. All files are only stored, they isn´t compressed - precisely, AMilionRandomDigits was compressed below 50%, but goal of this challenge is to compress AMillionRandomDigits.bin or .txt alongside the size of your compressor and it must be smaller than AMillionRandomDigits.bin.

Ah, you said that you don´t have resources to developing softwares? It´s possible to convert python script to standalone software using youtube tutorials. Conversion is pretty straightforward. Try this, post software here and we can test your algorithm and see if you´re able to compress even pure random content such as SHARND. That could help you to determine where you are in terms of compression.

I won´t saying that it´s impossible to compress random data, I´m saying YOUR method does not work as you claimed.

AMilionRandomDigits was compressed below 50%
But we need to recovery file with name and we can't use zip because zip is different algorithm and it's already patent.
That here this method works but is too slow, it compress 10 bytes per second:

from multiprocessing import Pool,Value
import os
def f(x):

return 16383**(x+1)

if __name__ == '__main__':
pool = Pool(processes=4)               # start 4 worker processes
#result = pool.apply_async(f, [147456])     # evaluate "f(10)" asynchronously
#print(result.get(timeout=1))           # prints "100" unless your computer is *very* slow
#print(pool.map(f, range(147456)))          # prints "[0, 1, 4,..., 81]"

import binascii
import json
block=147456
blockw=147455
blockw1=16384
virationc=16383
bitc=14
a=0
qfl=0
h=0
lenf1=0
byteb=""
notexist=""
lenf=0
numberschangenotexistq = []
qwa=0
z=0
m = []
p=0
asd=""
b=0
szx=""
asf2="0b"
while b<blockw1:
m+=[-1]
b=b+1
k = []
wer=""
numberschangenotexist = []
numbers = []
name = input("What is name of file? ")
namea="file.Spring"
namem=name+"/"
s=""
qwt=""
sda=""
ert=0
aqwer=0
aqwq=0
aqwers=0
qwaw=""
with open(namea, "w") as f4:
f4.write(s)
with open(namea, "a") as f3:
f3.write(namem)
with open(name, "rb") as binary_file:
lenf1=len(data)
if lenf1<300000:
print("This file is too small");
raise SystemExit
s=str(data)
lenf=len(data)
sda=bin(int(binascii.hexlify(data),16))[2:]
szx=""
lenf=len(sda)
xc=8-lenf%8
z=0
if xc!=0:
if xc!=8:
while z<xc:
szx="0"+szx
z=z+1
sda=szx+sda
lenf=len(sda)
szx=""
for byte in sda:
aqwer=aqwer+1
aqwers=aqwers+1
qwaw=qwaw+byte

if aqwer<=bitc:
qwt=qwt+byte
if aqwer==bitc:
aqwq=int(qwt,2)
qwt=""
a=a+1
h=h+1
av=bin(aqwq)
if a<=block and aqwer==bitc:
aqwer=0
m[aqwq] = aqwq
numbers.append(aqwq)
if a == block:
qwaw=""
p=0
while p<blockw1:
if p!=m[p]:
k.append(p)
p=p+1
lenfg=len(k)
if lenfg>0:
acvb=lenfg-1
notexist=k[acvb]
if notexist<8192:
raise SystemExit
notexist=notexist-8192
szx=bin(notexist)[2:]
lenf=len(szx)
xc=13-lenf
notexist=notexist+8192
z=0
if xc!=0:
while z<xc:
szx="0"+szx
z=z+1
wer=wer+szx
lenf=len(szx)
szx=""
if lenfg==0:
raise SystemExit
b=-1
kl=blockw
cb=0
er=-1
ghj=0
ghjd=1
bnk=1
p=0
cvz=0

for p in range(blockw):
if lenfg>0:
if virationc!=numbers[p]:
byteb=numbers[p]
numberschangenotexist.append(byteb)
if virationc==numbers[p]:
numberschangenotexist.append(notexist)
ghj=numberschangenotexist[p]
qfl=qfl+1
ghjd=ghj
bnk=1
bnkw=1
bnkd=1
kl=kl-1

if lenfg>0:

if blockw>=1 and blockw>=10000:
result = pool.apply_async(f, [kl])     # evaluate "f(10)" asynchronously
bnkw=result.get(timeout=0.5)

with open("pause", "r") as text:
if datah=="*":
os.system("pause")
ghjd=0
ghjd=ghj*bnkw

cvz=cvz+ghjd

szx=bin(cvz)[2:]
cvz=0
lenf=len(szx)
print(lenf)
if lenfg>0:
xc=2064370-lenf
z=0
if xc!=0:
while z<xc:
szx="0"+szx
z=z+1
wer=wer+szx
lenf=len(szx)
szx=""
a=0
numberschangenotexist = []
del k[:]
del numbers[:]
m = []
b=0
while b<blockw1:
m+=[-1]
b=b+1
b=0

a=0
wer=wer+qwaw
qwaw=""
wer="1"+wer+"1"
lenf=len(wer)
xc=8-lenf%8
z=0
if xc!=0:
if xc!=8:
while z<xc:
szx="0"+szx
z=z+1
wer=wer+szx
lenf=len(szx)
szx=""
wer="0b"+wer
n = int(wer, 2)
jl=binascii.unhexlify('%x' % n)
with open(namea, "ab") as f2ww:
f2ww.write(jl)



8. Spring 1.0.0.2
But I don’t care because installer is bad and can compile by errors so, use software by compile.

9. I will change my code from REXX to python. I use an algorithm like btw plus like RLE
Here is a random file that was decoding and every second, third line has 1-2 6-9 bits ones I will translate it calculus compress it.

01001110001001110101011100110110001010110001101110 01110100001000111010111011011111101111010010101111 01010010101101011001

00101100111100011000110010111111100100110010101110001110000101010100111100110001000 0111101101111011110000100010010101011

10110100010000010110010111000011011101100100101010 01010111111010110010110011110111011010011011110100 11010110100011110110

110010101101100100001010101111100011101110111111111010011110000010000001101010010111000101100001000101111110001001101110

00100101110100010100110000110111010100010111000000 10110100010100001100000111010001100001001010001011 01001010100000110010

01000010101001001100100000101100110001100110101110 1110101110101111101111101100100111111100010100101010001000010100001110

11011001110111110000110010001100010111110001111101 01001000000111110111010111010111010001100111111000 10101011001011100000

01001000010010110010000000010010000010100010101011 10001110111111100100111011100000111101010001111100011110101110111 00000

11101111110111101110100110011000010001101101100111011111111101000101110011011010101101000000100111000010111010 1100100101

110100000011111101001011011000001101001011100100110010000010011101 10111001110111011000010100011010100010010011000000 1000

10. It has two steps of compression. I use two methods for compression first method speed 45KB/s second speed 3.6KB/s second all is together is 2.65KB/s.

11. 2019-07-04.bin 1,048,576 bytes
fileqs.Spring 1,045,938 bytes
Time: ‏‎16:52:03 ‏‎17:03:55
Speed: 1.44KB/s

12. 1,048,576 bytes 2019-07-04.bin
1,046,278 bytes fileqs.Spring
Time: 14:40:52 14:46:18
Speed: 2.65KB/s.

13. https://www.livescience.com/amp/goog...supremacy.html

Google claim their quantum computer supremacy. And now maybe they are able to create all possible pattern from 2^75000000 in no time

14. 1. The experiment they did was "finding the most likely bitstrings for a random quantum circuit on a classical computer becomes exponentially more difficult as the number of qubits (width) and number of gate cycles (depth) grow."
So wow, they managed to beat normal computers simulating a quantum circuit with an actual quantum circuit.

2. Configuration is: "The quantum supremacy experiment was run on a fully programmable 54-qubit processor named “Sycamore.” It’s comprised of a two-dimensional grid where each qubit is connected to four other qubits."
That's very little. Maybe it can be used to crack crc16, at best.

3. Time is discrete. "Planck time" is ~1/2^144, so an abstract perfect quantum processor would be able to test all combinations of 144 bits per second... or 169 bits per year.
That won't even change much in cryptography, far from allowing for practical kolmogorov compression, or some such.

Here is my algorithm:
It could can compress file bigger then >=20 bytes
blockw=6 Bytes
We delete all zeros in the start. 1 information is like this if lenfa>=((blockw*8)-2, not compression we take away that add zeroes and write them after first zero like zero, left size 6 Bytes and left like 0....x we take all ones and put it to then from like 1111.... to 0111... to the end, add zero or one to the end and calculate the longest and the longest of the latest bytes.
Another information that compresses and write in start ones and zero in the end after we take this zeroes from the first put in the front 0 if 0 long puts 0 alike this lenfa<=((blockw*8)-6), lenfa<=((blockw*8)-5) 111....001111..0....x. first 1 change to zero after all ones.
Write how times were compression size of 4 bytes.
Look like this:
0....x not compression information
111...001111..0...x compression information
01111....... On the end

16. Originally Posted by pacalovasjurijus
Random file of 100KB was compressed to 115 Bytes was compressed 31 Bytes.
​Interesting. Can you decompress it back to original file?

17. Here's something similar, but actually working: https://encode.su/threads/1211-Compressing-pi
Demonstrating 100x better compression than popular archivers is not really a problem,
its compressing _all_ files which is the problem.

18. Originally Posted by Shelwien
Here's something similar, but actually working: https://encode.su/threads/1211-Compressing-pi
Demonstrating 100x better compression than popular archivers is not really a problem,
its compressing _all_ files which is the problem.
Well, to compress all files i still choose 2^n or nCr formula. Create the short notation using that way.

19. Today is the last day from begin this year random file compression challenge https://encode.su/threads/1176-losel...ll=1#post59199
Because nobody claimed the prize and the prize shall not be extended in the new year, I decided to reward Shelwien with 1/3 of the prize because he managed to get at one random.org file 1/3 of the gain required https://encode.su/threads/3099-Compr...ll=1#post59915
Congrats and have all a good new year!

20. Originally Posted by Sportman
Today is the last day from begin this year random file compression challenge https://encode.su/threads/1176-losel...ll=1#post59199
Because nobody claimed the prize and the prize shall not be extended in the new year, I decided to reward Shelwien with 1/3 of the prize because he managed to get at one random.org file 1/3 of the gain required https://encode.su/threads/3099-Compr...ll=1#post59915
Congrats and have all a good new year!
Amazing. Congratulations, and keep move forward sir

21. and that random data are incompressible... ehm, that´s not quite true.
Incompressibility of random data - that´s term for beginners, not for experts like we are. Random data always contains patterns, yet these patterns are positioned quite far, so for compressors, these patterns cannot be simplified futrther - but, they´re only random-looking patterns...

22. "Random data" has multiple meanings:

1. Statistically random = impossible to predict = incompressible.

2. Generated by a random number generator = encrypted or compressed.

3. Digitized analog noise.

4. synonym for "any and all" ("random data is compressible" = any data of this size is compressible).

So, for 1-3 kinds of randomness, yeah, it may be possible to compress -
(1) is defined in terms of specific "common" statistical models,
(2) is not really random at all, just designed to be hard to deal with for current computers
(3) is named by method of generation, but can be actually compressible even with normal methods

But for (4) there's a simple proof that if some instances of data can be compressed, then others must be expanded.

23. Thanks:

CompressMaster (7th January 2020)

24. We take infromation and move to the center with written what and where it was. We alredy have algorithm and demo version:

25. Originally Posted by pacalovasjurijus
We take infromation and move to the center with written what and where it was. We alredy have algorithm and demo version:

26. Hello there, anyone know what the name of this mechanism?

Some kind of rotation system.

Attachment 7255
Thank you

27. Our algorithm rotation working I already compressed .paq8o one byte.

28. Universal algorithm

Universal code (data compression)

Fibonacci, Elias Gamma, and Elias Delta vs binary coding

Rice with k = 2, 3, 4, 5, 8, 16 versus binary

In data compression, a universal code for integers is a prefix code that maps the positive integers onto binary codewords, with the additional property that whatever the true probability distribution on integers, as long as the distribution is monotonic (i.e., p(i) ≥ p(i + 1) for all positive i), the expected lengths of the codewords are within a constant factor of the expected lengths that the optimal code for that probability distribution would have assigned. A universal code is asymptotically optimal if the ratio between actual and optimal expected lengths is bounded by a function of the information entropy of the code that, in addition to being bounded, approaches 1 as entropy approaches infinity.
In general, most prefix codes for integers assign longer codewords to larger integers. Such a code can be used to efficiently communicate a message drawn from a set of possible messages, by simply ordering the set of messages by decreasing probability and then sending the index of the intended message. Universal codes are generally not used for precisely known probability distributions, and no universal code is known to be optimal for any distribution used in practice.
A universal code should not be confused with universal source coding, in which the data compression method need not be a fixed prefix code and the ratio between actual and optimal expected lengths must approach one. However, note that an asymptotically optimal universal code can be used on independent identically-distributed sources, by using increasingly large blocks, as a method of universal source coding.
Universal and non-universal codes

These are some universal codes for integers; an asterisk (*) indicates a code that can be trivially restated in lexicographical order, while a double dagger () indicates a code that is asymptotically optimal:

These are non-universal ones:

Their nonuniversality can be observed by noticing that, if any of these are used to code the Gauss–Kuzmin distribution or the Zeta distribution with parameter s=2, expected codeword length is infinite. For example, using unary coding on the Zeta distribution yields an expected length of
E ( l ) = 6 π 2 ∑ l = 1 ∞ 1 l = ∞ . {\displaystyle E(l)={\frac {6}{\pi ^{2}}}\sum _{l=1}^{\infty }{\frac {1}{l}}=\infty .\,} On the other hand, using the universal Elias gamma coding for the Gauss–Kuzmin distribution results in an expected codeword length (about 3.51 bits) near entropy (about 3.43 bits)[2][permanent dead link].
Relationship to practical compression

Huffman coding and arithmetic coding (when they can be used) give at least as good, and often better compression than any universal code.
However, universal codes are useful when Huffman coding cannot be used — for example, when one does not know the exact probability of each message, but only knows the rankings of their probabilities.
Universal codes are also useful when Huffman codes are inconvenient. For example, when the transmitter but not the receiver knows the probabilities of the messages, Huffman coding requires an overhead of transmitting those probabilities to the receiver. Using a universal code does not have that overhead.
Each universal code, like each other self-delimiting (prefix) binary code, has its own "implied probability distribution" given by p(i)=2l(i) where l(i) is the length of the ith codeword and p(i) is the corresponding symbol's probability. If the actual message probabilities are q(i) and Kullback–Leibler divergence DKL(q||p) is minimized by the code with l(i), then the optimal Huffman code for that set of messages will be equivalent to that code. Likewise, how close a code is to optimal can be measured by this divergence. Since universal codes are simpler and faster to encode and decode than Huffman codes (which is, in turn, simpler and faster than arithmetic encoding), the universal code would be preferable in cases where DKL(q||p) is sufficiently small. [3]
For any geometric distribution (an exponential distribution on integers), a Golomb code is optimal. With universal codes, the implicit distribution is approximately a power law such as 1 / n 2 {\displaystyle 1/n^{2}} (more precisely, a Zipf distribution). For the Fibonacci code, the implicit distribution is approximately 1 / n q {\displaystyle 1/n^{q}} , with
q = 1 / log 2 ⁡ ( φ ) ≃ 1.44 , {\displaystyle q=1/\log _{2}(\varphi )\simeq 1.44,} where φ {\displaystyle \varphi } is the golden ratio. For the ternary comma code (i.e., encoding in base 3, represented with 2 bits per symbol), the implicit distribution is a power law with q = 1 + log 3 ⁡ ( 4 / 3 ) ≃ 1.26 {\displaystyle q=1+\log _{3}(4/3)\simeq 1.26} . These distributions thus have near-optimal codes with their respective power laws.

Universal code (data compression)

Fibonacci, Elias Gamma, and Elias Delta vs binary coding

Rice with k = 2, 3, 4, 5, 8, 16 versus binary

In data compression, a universal code for integers is a prefix code that maps the positive integers onto binary codewords, with the additional property that whatever the true probability distribution on integers, as long as the distribution is monotonic (i.e., p(i) ≥ p(i + 1) for all positive i), the expected lengths of the codewords are within a constant factor of the expected lengths that the optimal code for that probability distribution would have assigned. A universal code is asymptotically optimal if the ratio between actual and optimal expected lengths is bounded by a function of the information entropy of the code that, in addition to being bounded, approaches 1 as entropy approaches infinity.
In general, most prefix codes for integers assign longer codewords to larger integers. Such a code can be used to efficiently communicate a message drawn from a set of possible messages, by simply ordering the set of messages by decreasing probability and then sending the index of the intended message. Universal codes are generally not used for precisely known probability distributions, and no universal code is known to be optimal for any distribution used in practice.
A universal code should not be confused with universal source coding, in which the data compression method need not be a fixed prefix code and the ratio between actual and optimal expected lengths must approach one. However, note that an asymptotically optimal universal code can be used on independent identically-distributed sources, by using increasingly large blocks, as a method of universal source coding.
Universal and non-universal codes

These are some universal codes for integers; an asterisk (*) indicates a code that can be trivially restated in lexicographical order, while a double dagger () indicates a code that is asymptotically optimal:

These are non-universal ones:

Their nonuniversality can be observed by noticing that, if any of these are used to code the Gauss–Kuzmin distribution or the Zeta distribution with parameter s=2, expected codeword length is infinite. For example, using unary coding on the Zeta distribution yields an expected length of
E ( l ) = 6 π 2 ∑ l = 1 ∞ 1 l = ∞ . {\displaystyle E(l)={\frac {6}{\pi ^{2}}}\sum _{l=1}^{\infty }{\frac {1}{l}}=\infty .\,} On the other hand, using the universal Elias gamma coding for the Gauss–Kuzmin distribution results in an expected codeword length (about 3.51 bits) near entropy (about 3.43 bits)[2][permanent dead link].
Relationship to practical compression

Huffman coding and arithmetic coding (when they can be used) give at least as good, and often better compression than any universal code.
However, universal codes are useful when Huffman coding cannot be used — for example, when one does not know the exact probability of each message, but only knows the rankings of their probabilities.
Universal codes are also useful when Huffman codes are inconvenient. For example, when the transmitter but not the receiver knows the probabilities of the messages, Huffman coding requires an overhead of transmitting those probabilities to the receiver. Using a universal code does not have that overhead.
Each universal code, like each other self-delimiting (prefix) binary code, has its own "implied probability distribution" given by p(i)=2l(i) where l(i) is the length of the ith codeword and p(i) is the corresponding symbol's probability. If the actual message probabilities are q(i) and Kullback–Leibler divergence DKL(q||p) is minimized by the code with l(i), then the optimal Huffman code for that set of messages will be equivalent to that code. Likewise, how close a code is to optimal can be measured by this divergence. Since universal codes are simpler and faster to encode and decode than Huffman codes (which is, in turn, simpler and faster than arithmetic encoding), the universal code would be preferable in cases where DKL(q||p) is sufficiently small. [3]
For any geometric distribution (an exponential distribution on integers), a Golomb code is optimal. With universal codes, the implicit distribution is approximately a power law such as 1 / n 2 {\displaystyle 1/n^{2}} (more precisely, a Zipf distribution). For the Fibonacci code, the implicit distribution is approximately 1 / n q {\displaystyle 1/n^{q}} , with
q = 1 / log 2 ⁡ ( φ ) ≃ 1.44 , {\displaystyle q=1/\log _{2}(\varphi )\simeq 1.44,} where φ {\displaystyle \varphi } is the golden ratio. For the ternary comma code (i.e., encoding in base 3, represented with 2 bits per symbol), the implicit distribution is a power law with q = 1 + log 3 ⁡ ( 4 / 3 ) ≃ 1.26 {\displaystyle q=1+\log _{3}(4/3)\simeq 1.26} . These distributions thus have near-optimal codes with their respective power laws.

29. Algorithm WhiteHall

​  if szxx[0:3]=="110":
qqw1q="1"

rr12=0

rr1=rr1+1
qqqsll=""

if rr1>=1:
qqqslls="10"+szxx[3:10]+szxx[10:32]

#print(qqqsll)

ss=10
elif szxx[0:3]=="111":
qqw1q="10"

rr12=0

rr1=rr1+1
qqqsll=""

if rr1>=1:
qqqsll="11"+szxx[3:10]+szxx[10:32]

asaaqll=asaaqll+qqqsll

ss=10
else:
qqqslls=""
st=len(qqqsll)

if rr1>=1:
wer=wer+"11"
asaaqll=asaaqll+"0"
qqqsll=""
rr1=0
wer=wer+szxx
ww=10
ss=10



30. WhiteHall paq 1.0.0.1.3 version 1.0.0.1.3
Before 100 000 000Bytes Enwik8
After 49Bytes Enwik8.b
Time 4 hours 10 minutes.

Page 8 of 9 First ... 6789 Last

Posting Permissions

• You may not post new threads
• You may not post replies
• You may not post attachments
• You may not edit your posts
•