Huffen v1.21
Door Danny Roelofs, 22 jaar geleden, 5.545x bekeken
Project: Huffen v1.21:
Requirements: Php 5.1 or higher
Meer informatie staat in de script zelf, in het kort:
1. Twee nieuwe functie's toegevoegd waardoor biniare
informatie kan worden omgezet naar hexadecimale'n
zodat we betrouwbaarder informatie kan opslaan in
een my(sql) database of om gecomprimeerde inhoud
mee te nemen in een php bestand zoals voorbeeld #4
Gesponsorde koppelingen
PHP script bestanden
Er zijn 16 reacties op 'Huffen v121'
0 
-0 
-0
Volgens mij snappen veel mensen niet waarvoor ze het kunnen gebruiken ;)
0 -0
-0
Ik had gisteren al de neiging om diezelfde vraag te stellen. Ik had alleen niet het hele script goed gelezen (had daar ook weinig trek in eigenlijk, omdat al niet duidelijk was wat het doet) en snapte er niets van.
Dacht dat er vast wel mensen waren die het wel snapten, maar blijkbaar niet... ik sta niet alleen in mijn "onkunde" :P
Dacht dat er vast wel mensen waren die het wel snapten, maar blijkbaar niet... ik sta niet alleen in mijn "onkunde" :P
0 -0
-0
Volgens mij kan dit script binary data in hexdeciamele data omzetten en anderzom.
Daarnaast kan zover ik er wijs uit wordt ook een compressie en decompressie worden toegepast
Daarnaast kan zover ik er wijs uit wordt ook een compressie en decompressie worden toegepast
0 -0
-0
Volgens mij is het een compressietechniek dat je een lap tekst, of wat dan ook neemt, daar de patronen in herkent, het bestand opdeelt in stukjes. Die stukjes zijn dan een soort templates. Alle stukjes in de echte data worden dan verwisseld met verwijzingen naar die tabel met 'templates'. Alle stukjes in die tabel zijn uiteraard uniek. Zo zou je dus winst moeten kunnen behalen doordat er geen dubbele stukjes meer in het bestand aanwezig zijn, alleen maar dubbele verwijzingen. En de verwijzing is dan kleiner dan het orginele stukje, dus zou het een winst op moeten leveren.
Maar ik kan het fout hebben, dit is alleen wat ik me ergens uit een vaag verleden ergens van een of andere site kan herinneren.
Wat me trouwens opviel: Waarom gebruik je binnen de classe niet $this-> maar telkens Huffen:: om te verwijzen naar interne functies? En waarom bij iedere functie 'return $this'? Functies die geen uitvoer buiten de klasse hebben laat je gewoon niets returnen. Ook definieer je alleen maar 5 constanten aan het begin, maar niet de interne variabelen. Als je die wel van te voren zou definieren, zou dat ontzettend bijdragen aan het overzicht.
Misschien zou je nog een makkelijke functie kunnen bijleveren, ok 2, die gewoon invoer als een formaat slikken, en uitvoer het formaat omgezet, zodat de gebruiker niet hoeft op te letten wat hij met de tabellen met stukjes doet, maar het gewoon 'werkt'.
Het zijn een paar ideeën...
Maar ik kan het fout hebben, dit is alleen wat ik me ergens uit een vaag verleden ergens van een of andere site kan herinneren.
Wat me trouwens opviel: Waarom gebruik je binnen de classe niet $this-> maar telkens Huffen:: om te verwijzen naar interne functies? En waarom bij iedere functie 'return $this'? Functies die geen uitvoer buiten de klasse hebben laat je gewoon niets returnen. Ook definieer je alleen maar 5 constanten aan het begin, maar niet de interne variabelen. Als je die wel van te voren zou definieren, zou dat ontzettend bijdragen aan het overzicht.
Misschien zou je nog een makkelijke functie kunnen bijleveren, ok 2, die gewoon invoer als een formaat slikken, en uitvoer het formaat omgezet, zodat de gebruiker niet hoeft op te letten wat hij met de tabellen met stukjes doet, maar het gewoon 'werkt'.
Het zijn een paar ideeën...
0 -0
-0
Ik zie het, tijd om te reageren :D,
De class richt zich op compressie en decompressie volgens een methode
van David A Huffman. De persoon heeft toen bedacht om ASCII gegevens
opnieuw een biniare code te geven.
Dit kan omdat er volgens ASCII 256 zijn gedefineerd maar je gebruikt ze
amper in een tekst bestand. Kortom wat de class zelf doet met dit als
voorbeeld:
Inhoud = GEEN
Hoeveel letter soorten zijn er, en hoe vaak komen ze voor.
G = 1x
E = 2x
N = 1x
Nu moet er een boom worden gebouwd, de letters zijn de leaf's die je
moet verbinden aan een node door de twee letters te kiezen waarvan
hun waardes het laagste zijn en die aan éen node te verbinden en
op te tellen:
(2)
.+.
N G
(1) (1)
--
UPDATE: jammer dit wordt niet goed getoond, terwijl in de editor dit wel goed
staat
---
Dan blijft er in dit geval nog de E over en gezien de eerste Node (2) is en
je nog maar 2 leafs over hebt, een node als leaf en een karakter als leaf
kom je uit op:
(4)
...........+..............
(2) E
.+. (2)
N G
(1) (1)
--
UPDATE: jammer dit wordt niet goed getoond, terwijl in de editor dit wel goed
staat
---
De laatste node die leafs kon koppelen is de root, de boom is klaar en nu
heeft elke karakter een nieuwe biniare code door de boom te doorlopen.
Linksaf = 0
rechtsaf = 1
N = linksaf, linksaf
E = rechtsaf
G = linksaf, rechtsaf
Endus:
N=00
E=1
G=01
Het woord zou normaal gesproken 4 x 8 bits aan opslag ruimte kosten
Maar nu kan het woord geschreven worden als 011100 en dit zijn maar
zes bits. Uiteraard moet je een decoderings tabel meeschrijven in het
bestand om het later weer te kunnen ontcijferen. Compressie werkt
naargelang de frequentie van karakters hoog is en de diversieteit laag.
Met deze methode haal je bij een A4'tje vol met gewone tekst al gauw
30% rendement.
-------------------------------------------------------------
Verder wat heb je eraan, nou voornamelijk de hex converter maakt het dan
al enigzins toepasbaar omdat je dus een project uit meerdere bestanden
kan compressen, omzetten naar hex en alles in éen bestand kan verwerken
om zo een installatie script te maken gebaseerd op 1 bestand.
Zelf heb ik er baat bij voor het opslaan van data, en de inhoud van de data
is gebonden aan de decoding tabel die dus werkt als een soort sleutel. nu is
de sleutel nog te groot om eventjes in te typen maar het gaat er mij om data
te beveiligen door inhoud en decoding tables apart te houden.
De class is voor mij zelf niet meer dan een benodigde set aan functie's die ik
later gebruik in andere projecten. maar verder was het ook de uitdaging.
---------------------------------------------------------------------------------
Wat betreft de class code en dat ik huffen::functie() doe is eigenlijk wat
spelen met OOP, ik wilde even het gebruiksgemak testen.
---------------------------------------------------------------------------------
Ja wat betreft de functie nog makkelijker te maken, dat komt er ook nog
wel bij. er komen zowiezo functie's erbij om gewoon een bestand aan
te wijzen waar je van leest en waar je naar toe wil schrijven.
----------------------------------------------------------------------------------
Maar we schonen nog eerst de code een beetje op, kijken hoe we het zo
kort mogelijk houden en ik moet nog de nodige commentaar plaatsen voor
mezelf anders ben ik het over een half jaartje weer kwijt wat ik gedaan heb
want alles heb ik op trail&error gedaan en al denkend geprogrammeert.
Dat werkt voor mij vaak wel goed gezien ik een "denker" ben maar ja dat
is alleen tijdens het project ;D
In iedergeval bedankt voor jullie reactie's, input is altijd belangrijk voor mij
om te zien wat de wensen zijn.
De class richt zich op compressie en decompressie volgens een methode
van David A Huffman. De persoon heeft toen bedacht om ASCII gegevens
opnieuw een biniare code te geven.
Dit kan omdat er volgens ASCII 256 zijn gedefineerd maar je gebruikt ze
amper in een tekst bestand. Kortom wat de class zelf doet met dit als
voorbeeld:
Inhoud = GEEN
Hoeveel letter soorten zijn er, en hoe vaak komen ze voor.
G = 1x
E = 2x
N = 1x
Nu moet er een boom worden gebouwd, de letters zijn de leaf's die je
moet verbinden aan een node door de twee letters te kiezen waarvan
hun waardes het laagste zijn en die aan éen node te verbinden en
op te tellen:
(2)
.+.
N G
(1) (1)
--
UPDATE: jammer dit wordt niet goed getoond, terwijl in de editor dit wel goed
staat
---
Dan blijft er in dit geval nog de E over en gezien de eerste Node (2) is en
je nog maar 2 leafs over hebt, een node als leaf en een karakter als leaf
kom je uit op:
(4)
...........+..............
(2) E
.+. (2)
N G
(1) (1)
--
UPDATE: jammer dit wordt niet goed getoond, terwijl in de editor dit wel goed
staat
---
De laatste node die leafs kon koppelen is de root, de boom is klaar en nu
heeft elke karakter een nieuwe biniare code door de boom te doorlopen.
Linksaf = 0
rechtsaf = 1
N = linksaf, linksaf
E = rechtsaf
G = linksaf, rechtsaf
Endus:
N=00
E=1
G=01
Het woord zou normaal gesproken 4 x 8 bits aan opslag ruimte kosten
Maar nu kan het woord geschreven worden als 011100 en dit zijn maar
zes bits. Uiteraard moet je een decoderings tabel meeschrijven in het
bestand om het later weer te kunnen ontcijferen. Compressie werkt
naargelang de frequentie van karakters hoog is en de diversieteit laag.
Met deze methode haal je bij een A4'tje vol met gewone tekst al gauw
30% rendement.
-------------------------------------------------------------
Verder wat heb je eraan, nou voornamelijk de hex converter maakt het dan
al enigzins toepasbaar omdat je dus een project uit meerdere bestanden
kan compressen, omzetten naar hex en alles in éen bestand kan verwerken
om zo een installatie script te maken gebaseerd op 1 bestand.
Zelf heb ik er baat bij voor het opslaan van data, en de inhoud van de data
is gebonden aan de decoding tabel die dus werkt als een soort sleutel. nu is
de sleutel nog te groot om eventjes in te typen maar het gaat er mij om data
te beveiligen door inhoud en decoding tables apart te houden.
De class is voor mij zelf niet meer dan een benodigde set aan functie's die ik
later gebruik in andere projecten. maar verder was het ook de uitdaging.
---------------------------------------------------------------------------------
Wat betreft de class code en dat ik huffen::functie() doe is eigenlijk wat
spelen met OOP, ik wilde even het gebruiksgemak testen.
---------------------------------------------------------------------------------
Ja wat betreft de functie nog makkelijker te maken, dat komt er ook nog
wel bij. er komen zowiezo functie's erbij om gewoon een bestand aan
te wijzen waar je van leest en waar je naar toe wil schrijven.
----------------------------------------------------------------------------------
Maar we schonen nog eerst de code een beetje op, kijken hoe we het zo
kort mogelijk houden en ik moet nog de nodige commentaar plaatsen voor
mezelf anders ben ik het over een half jaartje weer kwijt wat ik gedaan heb
want alles heb ik op trail&error gedaan en al denkend geprogrammeert.
Dat werkt voor mij vaak wel goed gezien ik een "denker" ben maar ja dat
is alleen tijdens het project ;D
In iedergeval bedankt voor jullie reactie's, input is altijd belangrijk voor mij
om te zien wat de wensen zijn.
0 -0
-0
hé dat is wel cool...
alleen jammer dat ik van jou uitleg hoe het werkt niet veel snap...
volgens mij als je je regeltjes in [.code.] (zonder die punten) tags of PHP tags zet, komt het er pel goed uit:
ik denk dat het zoiets had moeten zijn?
alleen jammer dat ik van jou uitleg hoe het werkt niet veel snap...
volgens mij als je je regeltjes in [.code.] (zonder die punten) tags of PHP tags zet, komt het er pel goed uit:
ik denk dat het zoiets had moeten zijn?
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
________________
(4)
...........+..............
(2) E
.+. (2)
N G
(1)(1)
(4)
...........+..............
(2) E
.+. (2)
N G
(1)(1)
0 -0
-0
Dit is precies wat er stond:
:P
Code (php)
1
2
3
4
5
6
2
3
4
5
6
. (4)
...........+..............
(2) E
.+. (2)
N G
(1) (1)
...........+..............
(2) E
.+. (2)
N G
(1) (1)
:P
0 -0
-0
Grafisch voorbeeld op het internet, dit is in het kort wat de code doet:
http://www.iti.fh-flensburg.de/lang/algorithmen/code/huffman/huff7.gif
Onderaan zie je alle letters zoals bijvoorbeeld:
e ( 4 ) = e komt 4x voor
m ( 1 ) = m komt 1x voor
Het aantal keren wat een karakter voorkomt noem ik vanaf nu even de "waarde" en dus is het de bedoeling om twee karakters te kiezen
welke de minste waarde hebben en die op te tellen.
Zo zie je dat de M en W worden opgeteld en samen worden geknoopt.
Deze zogenaamde node krijgt dan de som van de waarde's
En zo ga je door met steeds de twee karakters te pakken die de laagste
waarde hebben totdat er geen of nog maar 1 karakter over is en dan
ga je de node's zoeken met de laagste waarde en weer de som noteren.
Dit gaat net zo lang door tot dat je een begin punt hebt, ofwel er geen
karakters of node's meer te vinden zijn die nog gekoppeld kunnen worden.
Maar het plaatje zal niet geheel kloppen met wat ik nu zeg, dit komt omdat
er verschillende manieren zijn om een nog betere verhouding te krijgen.
Maar globaal gezien klopt de methode.
Ik zal binnenkort met een duidelijke pagina op mijn website komen en dan
probeer ik het ook op een eenvoudige manier uit te leggen. Op dit moment
ben ik eventjes bezig om de code op te schonen en wat tips op te volgen
hoe het wat netter en overzichtelijker maar ook wat overbodige dingen
worden verwijderd zoals de "return $this" terwijl dat niet nodig is.
Maar dat komt een beetje doordat ik experimenteerde met PHP5 OOP maar
ik doe PHP4 gebruikers eerder een plezier als ik toch de PHP4 OOP model
aanhou want het is niet persee nodig om bv statische functie's te maken.
http://www.iti.fh-flensburg.de/lang/algorithmen/code/huffman/huff7.gif
Onderaan zie je alle letters zoals bijvoorbeeld:
e ( 4 ) = e komt 4x voor
m ( 1 ) = m komt 1x voor
Het aantal keren wat een karakter voorkomt noem ik vanaf nu even de "waarde" en dus is het de bedoeling om twee karakters te kiezen
welke de minste waarde hebben en die op te tellen.
Zo zie je dat de M en W worden opgeteld en samen worden geknoopt.
Deze zogenaamde node krijgt dan de som van de waarde's
En zo ga je door met steeds de twee karakters te pakken die de laagste
waarde hebben totdat er geen of nog maar 1 karakter over is en dan
ga je de node's zoeken met de laagste waarde en weer de som noteren.
Dit gaat net zo lang door tot dat je een begin punt hebt, ofwel er geen
karakters of node's meer te vinden zijn die nog gekoppeld kunnen worden.
Maar het plaatje zal niet geheel kloppen met wat ik nu zeg, dit komt omdat
er verschillende manieren zijn om een nog betere verhouding te krijgen.
Maar globaal gezien klopt de methode.
Ik zal binnenkort met een duidelijke pagina op mijn website komen en dan
probeer ik het ook op een eenvoudige manier uit te leggen. Op dit moment
ben ik eventjes bezig om de code op te schonen en wat tips op te volgen
hoe het wat netter en overzichtelijker maar ook wat overbodige dingen
worden verwijderd zoals de "return $this" terwijl dat niet nodig is.
Maar dat komt een beetje doordat ik experimenteerde met PHP5 OOP maar
ik doe PHP4 gebruikers eerder een plezier als ik toch de PHP4 OOP model
aanhou want het is niet persee nodig om bv statische functie's te maken.
0 -0
-0
Ik krijg 6 notices. Je definieert je tijdelijke variabelen binnen de functies niet. Dus dat kan je misschien ook meteen meenemen.
0 -0
-0
het lijkt wel een soort boomdiagram, maar dan een kwartslag gedraaid :D
0 -0
-0
Dat is het ook (met blaatjes en wortels erbij). Het is de manier waarop rekenmachines sommetjes uitrekenen. Alles wordt verdeeld in stappen. En volgens een bepaalde order wordt er langs de boom gelopen. PRE, IN, POST, LEVEL... Tis wel efficient dat wel, omdat het anders 4* (7 of 8) bits is en met dit vb 6 bits voor het woord 'geen'.
Om te reageren heb je een account nodig en je moet ingelogd zijn.
PHP hulp
0 seconden vanaf nu