Hamming-koodi

Kokeneet kirjoittajat eivät ole vielä tarkistaneet sivun nykyistä versiota, ja se voi poiketa merkittävästi 2. maaliskuuta 2021 tarkistetusta versiosta . tarkastukset vaativat 12 muokkausta .

Binääri Hamming-koodi
Hamming-koodi kanssa ${\näyttötyyli (7,4)}$ $r = 3$
Nimetty	Richard Hamming
Tyyppi	lineaarinen lohkokoodi
Lohkon pituus	$2^{r}-1$
Viestin pituus	$2^{r}-r-1$
Jaa	$1-{\frac {2}{2^{r}-1))$
Etäisyys	3
Aakkosten koko	2
Nimitys	${\displaystyle [2^{r}-1,2^{r}-r-1,3]_{2))$
Mediatiedostot Wikimedia Commonsissa

Hamming-koodi on itseään tarkistava ja itsekorjaava koodi . Rakennettu viittaamalla binäärilukujärjestelmään .

Voit korjata yksittäisen virheen (virhe sanan yhdessä bitissä) ja löytää kaksinkertaisen [1] .

Nimetty amerikkalaisen matemaatikon Richard Hammingin mukaan, joka ehdotti koodia.

Historia

1940-luvun puolivälissä Bell Model V -laskentakone luotiin Bell Laboratoriesissa . Se oli relelohkoja käyttävä sähkömekaaninen kone, jonka nopeus oli erittäin alhainen: yksi toimenpide muutamassa sekunnissa. Tiedot syötettiin koneeseen rei'itetyillä korteilla epäluotettavien lukulaitteiden kanssa, joten lukuprosessissa tapahtui usein virheitä. Työpäivinä havaittiin ja korjattiin erikoiskoodeja, kun taas kuljettaja sai tietää virheestä valojen hehkusta, korjasi ja käynnisti koneen uudelleen. Viikonloppuisin, kun käyttäjiä ei ollut, kone poistui automaattisesti ohjelmasta ja aloitti uuden virheen sattuessa.

Hamming työskenteli usein viikonloppuisin ja suuttui yhä enemmän, kun hänen täytyi ladata ohjelmansa uudelleen reikäkortinlukijan epäluotettavuuden vuoksi. Hän etsi useita vuosia tehokasta virheenkorjausalgoritmia. Vuonna 1950 hän julkaisi koodausmenetelmän, joka tunnetaan nimellä Hamming-koodi.

Systemaattiset koodit

Systemaattiset koodit muodostavat suuren ryhmän lohkoisia, erotettavia koodeja (joissa sanan kaikki symbolit voidaan jakaa varmennukseen ja informaatioon). Systemaattisten koodien ominaisuus on, että tarkistussymbolit muodostuvat informaatiosymbolien lineaaristen loogisten operaatioiden tuloksena. Lisäksi mikä tahansa sallittu koodisana voidaan saada lineaarisesti riippumattomien koodisanojen joukon lineaaristen operaatioiden tuloksena.

Itsetarkistuskoodit

Hamming-koodit ovat itsevalvontakoodeja, eli koodeja, jotka havaitsevat automaattisesti tiedonsiirron virheet. Niiden rakentamiseksi riittää, että määrität jokaiseen sanaan yksi ylimääräinen (ohjaus) binäärinumero ja valitset tämän numeron numeron siten, että minkä tahansa luvun kuvassa olevien yksiköiden kokonaismäärä on esimerkiksi pariton. Yksittäinen virhe missä tahansa lähetetyn sanan numerossa (mukaan lukien ehkä tarkistusnumero) muuttaa yksiköiden kokonaismäärän pariteetin. Modulo 2 -laskurit, jotka laskevat luvun binäärinumeroiden joukossa olevia ykkösiä, antavat signaalin virheiden olemassaolosta. Tässä tapauksessa on mahdotonta tietää, missä sanan kohdassa virhe tapahtui, ja siksi sitä ei ole mahdollista korjata. Myös virheet, jotka esiintyvät samanaikaisesti kahdessa, neljässä jne. - parillisessa määrässä numeroita, jäävät huomaamatta. Oletetaan, että kaksinkertaiset, ja vielä enemmän useat virheet ovat epätodennäköisiä.

Itsekorjautuvat koodit

Koodit, joissa automaattinen virheenkorjaus on mahdollista, kutsutaan itsekorjautuviksi. Yksittäisten virheiden korjaamiseen tarkoitetun itsekorjaavan koodin rakentamiseen yksi tarkistusnumero ei riitä. Kuten seuraavasta voidaan nähdä, ohjausbittien lukumäärä on valittava siten, että epäyhtälö tai täyttyy , missä on koodisanan informaatiobinääribittien lukumäärä. Tämän epäyhtälön mukaisesti löydetyt k:n vähimmäisarvot annetuille m:n arvoille on annettu taulukossa. $k$ $2^k \geq k+m+1$ $k \geq \log_2(k+m+1)$ $m$

Alue m	kmmin_ _
yksi	2
2-4	3
5-11	neljä
12-26	5
27-57	6

Binäärilohkokorjauskoodit kiinnostavat eniten . Tällaisia koodeja käytettäessä informaatio välitetään samanpituisten lohkojen muodossa ja jokainen lohko koodataan ja dekoodataan toisistaan riippumatta. Lähes kaikissa lohkokoodeissa symbolit voidaan jakaa informaatioon ja tarkastukseen tai ohjaukseen. Siten kaikki sanat jaetaan sallittuihin (joille tiedon ja tarkistusmerkkien suhde on mahdollinen) ja kiellettyihin.

Itsekorjautuvien koodien pääominaisuudet:

Sallittujen ja kiellettyjen yhdistelmien määrä. Jos - lohkon merkkien määrä, - lohkon tarkistusmerkkien määrä, - tietomerkkien määrä, niin - mahdollisten koodiyhdistelmien määrä, - sallittujen koodiyhdistelmien määrä, - kiellettyjen yhdistelmien määrä . $n$ $r$ $k$ $2^{n}$ $2^k$ ${\displaystyle 2^{n}-2^{k))$
Koodin redundanssi. Arvoa kutsutaan korjauskoodin redundanssiksi. ${\tfrac {r}{n))$
Koodin vähimmäisetäisyys. Vähimmäiskoodietäisyys on vääristyneiden symbolien vähimmäismäärä, joka tarvitaan siirtymään sallitusta yhdistelmästä toiseen. $d$
Havaittujen ja korjattujen virheiden määrä. Jos on virheiden määrä, jonka koodi pystyy korjaamaan, niin se on välttämätöntä ja riittävää $g$ $d\geq 2g+1$
Korjaavat koodit.

Plotkinin raja antaa koodin etäisyyden ylärajan:

d\leqslant {\tfrac {n\cdot 2^{k-1}}{2^{k}-1)),

tai:

r\geq 2\cdot (d-1)-\log _{2}d

klo

n\geq 2\cdot d-1.

Hamming-raja määrittää sallittujen koodiyhdistelmien enimmäismäärän:

2^{k}\leq {2^{n}}/\sum _{i=0}^{\tfrac {d-1}{2}}C_{n}^{i},

missä on elementtien yhdistelmien lukumäärä elementeillä. Täältä saat lausekkeen tarkistussymbolien määrän arvioimiseksi:

C_n^i

n

i

r\geq \log _{2}\left(\sum _{i=0}^{(d-1)/2}C_{n}^{i}\oikea).

Arvojen kohdalla ero Hammingin ja Plotkinin välillä on pieni. $(d/n)\leq 0{,}3$

Varshamov-Gilbertin rajoitus suurelle n:lle määrittää alarajan tarkistussymbolien lukumäärälle:

r\geq \log _{2}\left(\sum _{i=0}^{d-2}C_{n-1}^{i}\oikea).

Kaikki yllä olevat arviot antavat kuvan ylärajasta kiinteällä ja /tai alemmalla arviolla tarkistussymbolien lukumäärästä. $d$ $n$ $k$

Hamming-koodi

Hamming-koodien rakentaminen perustuu periaatteeseen, että yksittäisten merkkien määrä tarkistetaan pariteetin varalta: sellainen elementti lisätään sekvenssiin niin, että yksittäisten merkkien määrä tuloksena olevassa sekvenssissä on parillinen:

r_{1}=i_{1}\oplus i_{2}\oplus ...\oplus i_{k}.

Tämä merkki tarkoittaa modulo 2 -lisäystä : $\oplus$

S=i_{1}\oplus i_{2}\oplus ...\oplus i_{n}\oplus r_{1}.

Jos - niin ei ole virhettä, jos - niin yksi virhe. $S = 0$ $S=1$

Tällaista koodia kutsutaan nimellä tai . Ensimmäinen numero on sekvenssielementtien lukumäärä, toinen on tietomerkkien lukumäärä. ${\näyttötyyli (k+1,\ k)}$ ${\näyttötyyli (n,\ n-1)}$

Jokaiselle tarkistussymbolien määrälle on klassinen Hamming-koodi ja merkinnät: $r=3,\ 4,\ 5\ ...$

(n,k)=(2^{r}-1,2^{r}-1-r),

eli - .

{\näyttötyyli (7,4),(15,11),(31,26)}

Muilla arvoilla saadaan ns. katkaistu koodi, esimerkiksi kansainvälinen lennätinkoodi MTK-2, jolla on . Se vaatii Hamming-koodin, joka on lyhennetty versio klassikosta $k$ $k = 5$ ${\näyttötyyli (9,\ 5),}$ ${\näyttötyyli (15,\ 11).}$

Harkitse esimerkiksi klassista Hamming-koodia . Ryhmitetään tarkistussymbolit seuraavasti: ${\näyttötyyli (7,\ 4)}$

r_{1}=i_{1}\oplus i_{2}\oplus i_{3},

r_{2}=i_{2}\oplus i_{3}\oplus i_{4},

r_{3}=i_{1}\oplus i_{2}\oplus i_{4}.

Koodisanan saaminen näyttää tältä:

\begin{pmatrix} i_1 & i_2 & i_3 & i_4 & \\ \end{pmatrix}

\begin{pmatrix} 1 & 0 & 0 & 0 & 1 & 0 & 1 \\ 0 & 1 & 0 & 0 & 1 & 1 & 1 \\ 0 & 0 & 1 & 0 & 1 & 1 & 0 \\ 0 & 0 & 0 & 1 & 0 & 1 & 1 \\ \end{pmatrix}

= .

\begin{pmatrix} i_1 & i_2 & i_3 & i_4 & r_1 & r_2 & r_3 \\ \end{pmatrix}

Dekooderin tulo vastaanottaa koodisanan , jossa symbolit on merkitty viivalla, joka voi vääristyä häiriön seurauksena. Virheenkorjaustilassa olevaan dekooderiin rakennetaan oireyhtymien sarja: $V=(i_{1}',\ i_{2}',\ i_{3}',\ i_{4}',\ r_{1}',\ r_{2}',\ r_{ 3}')$

S_{1}=r_{1}\oplus i_{1}\oplus i_{2}\oplus i_{3},

S_{2}=r_{2}\oplus i_{2}\oplus i_{3}\oplus i_{4},

S_{3}=r_{3}\oplus i_{1}\oplus i_{2}\oplus i_{4}.

$S=(S_{1},\ S_{2},\ S_{3})$ kutsutaan sekvenssisyndroomaksi.

Syndroman saaminen näyttää tältä:

\begin{pmatrix} i_1 & i_2 & i_3 & i_4 & r_1 & r_2 & r_3 \\ \end{pmatrix}

\begin{pmatrix} 1 & 0 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 0 \\ 0 & 1 & 1 \\ 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \\ \end{pmatrix}

= .

{\begin{pmatrix}S_{1}&S_{2}&S_{3}\\\end{pmatrix}}

$i_1$	$i_2$	$i_3$	$i_4$	$r_{1}$	$r_{2}$	$r_3$	$i_1$	$i_2$	$i_3$	$i_4$	$r_{1}$	$r_{2}$	$r_3$
0	0	0	0	0	0	0	yksi	0	0	0	yksi	0	yksi
0	0	0	yksi	0	yksi	yksi	yksi	0	0	yksi	yksi	yksi	0
0	0	yksi	0	yksi	yksi	0	yksi	0	yksi	0	0	yksi	yksi
0	0	yksi	yksi	yksi	0	yksi	yksi	0	yksi	yksi	0	0	0
0	yksi	0	0	yksi	yksi	yksi	yksi	yksi	0	0	0	yksi	0
0	yksi	0	yksi	yksi	0	0	yksi	yksi	0	yksi	0	0	yksi
0	yksi	yksi	0	0	0	yksi	yksi	yksi	yksi	0	yksi	0	0
0	yksi	yksi	yksi	0	yksi	0	yksi	yksi	yksi	yksi	yksi	yksi	yksi

Hamming-koodin koodisanat on annettu taulukossa. ${\näyttötyyli (7,\ 4)}$

Oireyhtymä osoittaa, että sekvenssissä ei ole vääristymiä. Jokainen nollasta poikkeava oireyhtymä vastaa tiettyä virhekuviota, joka korjataan dekoodausvaiheessa. ${\näyttötyyli (0,0,0)}$

Oireyhtymä	001	010	011	100	101	110	111
Virhe kokoonpanossa	0000001	0000010	0001000	0000100	1000000	0010000	0100000
Symbolivirhe _	$r_3$	$r_{2}$	$i_4$	$r_{1}$	$i_1$	$i_3$	$i_2$

Oikeanpuoleisen taulukon koodille on ilmoitettu nollasta poikkeavat oireyhtymät ja niitä vastaavat virhekonfiguraatiot (lomakkeelle: ). ${\näyttötyyli (7,4)}$ $i_1$ $i_2$ $i_3$ $i_4$ $r_{1}$ $r_{2}$ $r_3$

Koodausalgoritmi

Oletetaan, että meidän on luotava Hamming-koodi jollekin informatiiviselle koodisanalle. Otetaan esimerkkinä 15-bittinen koodisana, vaikka algoritmi sopii minkä pituisille koodisanoille. Alla olevan taulukon ensimmäisellä rivillä on koodisanan paikkanumerot, toisella rivillä bittinimike ja kolmannella bittiarvot. $x_{1}\dots \ x_{15},$

yksi	2	3	neljä	5	6	7	kahdeksan	9	kymmenen	yksitoista	12	13	neljätoista	viisitoista
x 1	x2_ _	x 3	x4 _	x5_ _	x6 _	x 7	x 8	x9_ _	x 10	x 11	x 12	x 13	x 14	x 15
yksi	0	0	yksi	0	0	yksi	0	yksi	yksi	yksi	0	0	0	yksi

Lisätään informaatiosanaan ohjausbittejä siten, että niiden paikkanumerot ovat kahden kokonaislukupotenssit: 1, 2, 4, 8, 16 ... Saamme 20-bittisen sanan, jossa on 15 tietoa ja 5 ohjausbittiä. Aluksi ohjausbitit asetetaan nollaan. Kuvassa ohjausbitit on korostettu vaaleanpunaisella. ${\displaystyle r_{0}\dots \ r_{4))$

yksi	2	3	neljä	5	6	7	kahdeksan	9	kymmenen	yksitoista	12	13	neljätoista	viisitoista	16	17	kahdeksantoista	19	kaksikymmentä
r0_ _	r1_ _	x 1	r2_ _	x2_ _	x 3	x4 _	r3_ _	x5_ _	x6 _	x 7	x 8	x9_ _	x 10	x 11	r4_ _	x 12	x 13	x 14	x 15
0	0	yksi	0	0	0	yksi	0	0	0	yksi	0	yksi	yksi	yksi	0	0	0	0	yksi

Yleensä koodisanan ohjausbittien lukumäärä on yhtä suuri kuin koodisanan bittien lukumäärää suuremman luvun binäärilogaritmi (mukaan lukien ohjausbitit); logaritmi pyöristetään ylöspäin. Esimerkiksi 1-bittinen tietosana vaatii kaksi tarkistusbittiä, 2-, 3- tai 4-bittinen informaatiosana kolme, 5...11-bittinen tietosana vaatii neljä, 12...26-bittinen tietosana bittitietosana vaatii viisi ja niin edelleen.

Lisätään taulukkoon 5 riviä (ohjausbittien lukumäärän mukaan), joihin sijoitetaan muunnosmatriisi. Jokainen rivi vastaa yhtä ohjausbittiä (nolla ohjausbitti on ylin rivi, neljäs on alempi), jokainen sarake vastaa yhtä bittiä koodatusta sanasta. Jokaiseen muunnosmatriisin sarakkeeseen sijoitamme tämän sarakkeen binääriluvun ja bittien järjestys käännetään - vähiten merkitsevä bitti sijoitetaan ylimmälle riville, merkittävin - alariville. Esimerkiksi matriisin kolmas sarake sisältää luvut 11000, mikä vastaa luvun kolme binääriesitystä: 00011.

yksi	2	3	neljä	5	6	7	kahdeksan	9	kymmenen	yksitoista	12	13	neljätoista	viisitoista	16	17	kahdeksantoista	19	kaksikymmentä
r0_ _	r1_ _	x 1	r2_ _	x2_ _	x 3	x4 _	r3_ _	x5_ _	x6 _	x 7	x 8	x9_ _	x 10	x 11	r4_ _	x 12	x 13	x 14	x 15
0	0	yksi	0	0	0	yksi	0	0	0	yksi	0	yksi	yksi	yksi	0	0	0	0	yksi
yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	r0_ _
0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	r1_ _
0	0	0	yksi	yksi	yksi	yksi	0	0	0	0	yksi	yksi	yksi	yksi	0	0	0	0	yksi	r2_ _
0	0	0	0	0	0	0	yksi	yksi	yksi	yksi	yksi	yksi	yksi	yksi	0	0	0	0	0	r3_ _
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	yksi	yksi	yksi	yksi	yksi	r4_ _

Taulukon oikeaan osaan jäi tyhjäksi yksi sarake, johon sijoitamme ohjausbittien laskennan tulokset. Laskemme ohjausbitit seuraavasti: otamme yhden muunnosmatriisin riveistä (esimerkiksi ) ja etsimme sen skalaaritulon koodisanalla, eli kerromme molempien rivien vastaavat bitit ja löydämme Tuotteet. Jos summa osoittautui suuremmiksi kuin yksi, löydämme sen jaon jäännöksen 2:lla. Toisin sanoen lasketaan kuinka monta kertaa koodisanassa ja vastaavalla matriisin rivillä on yksiköitä samoissa paikoissa, ja ota tämä numero modulo 2. $r_{0}$

Jos kuvaamme tätä prosessia matriisialgebran avulla, niin operaatio on muunnosmatriisin kertominen koodisanan matriisisarakkeella, jolloin tuloksena on ohjausbittien matriisisarake, joka on otettava modulo 2.

Esimerkiksi riville : $r_{0}$

r_{0}

= (1 0+0 0+1 1+0 0+1 0+0 0+1 1+0 0+1 0+0 0+1 1+0 0+ 1 1+0 1+1 1+0 0+ 1 0+0 0+1 0+0 1) mod 2 = 5 mod 2 = 1.

Tuloksena saadut ohjausbitit lisätään koodisanaan aiemmin siellä olleiden nollien sijaan. Analogisesti löydämme tarkistusbitit jäljellä olevilta riveiltä. Hamming-koodaus on valmis. Vastaanotettu koodisana on 11110010001011110001.

yksi	2	3	neljä	5	6	7	kahdeksan	9	kymmenen	yksitoista	12	13	neljätoista	viisitoista	16	17	kahdeksantoista	19	kaksikymmentä
r0_ _	r1_ _	x 1	r2_ _	x2_ _	x 3	x4 _	r3_ _	x5_ _	x6 _	x 7	x 8	x9_ _	x 10	x 11	r4_ _	x 12	x 13	x 14	x 15
yksi	yksi	yksi	yksi	0	0	yksi	0	0	0	yksi	0	yksi	yksi	yksi	yksi	0	0	0	yksi
yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	r0_ _	yksi
0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	r1_ _	yksi
0	0	0	yksi	yksi	yksi	yksi	0	0	0	0	yksi	yksi	yksi	yksi	0	0	0	0	yksi	r2_ _	yksi
0	0	0	0	0	0	0	yksi	yksi	yksi	yksi	yksi	yksi	yksi	yksi	0	0	0	0	0	r3_ _	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	yksi	yksi	yksi	yksi	yksi	r4_ _	yksi

Dekoodausalgoritmi

Hamming-dekoodausalgoritmi on täysin identtinen koodausalgoritmin kanssa. Vastaavan ulottuvuuden muunnosmatriisi kerrotaan koodisana-sarakematriisilla, ja tuloksena olevan sarakematriisin jokainen elementti otetaan modulo 2. Tuloksena olevaa sarakematriisia kutsutaan "syndroomatriisiksi". On helppo varmistaa, että edellisessä osiossa kuvatun algoritmin mukaisesti generoitu koodisana antaa aina nollasyndroomamatriisin.

Syndroomamatriisista tulee nollasta poikkeava, jos virheen seurauksena (esimerkiksi lähetettäessä sanaa kohinaisen viestintälinjan yli) jokin alkuperäisen sanan biteistä on muuttanut arvoaan. Oletetaan esimerkiksi, että edellisessä osiossa saadussa koodisanassa kuudes bitti on muuttanut arvonsa nollasta yhdeksi (merkitty kuvassa punaisella). Sitten saadaan seuraava oireyhtymämatriisi.

yksi	2	3	neljä	5	6	7	kahdeksan	9	kymmenen	yksitoista	12	13	neljätoista	viisitoista	16	17	kahdeksantoista	19	kaksikymmentä
r0_ _	r1_ _	x 1	r2_ _	x2_ _	x 3	x4 _	r3_ _	x5_ _	x6 _	x 7	x 8	x9_ _	x 10	x 11	r4_ _	x 12	x 13	x 14	x 15
yksi	yksi	yksi	yksi	0	yksi	yksi	0	0	0	yksi	0	yksi	yksi	yksi	yksi	0	0	0	yksi
yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	yksi	0	s0_ _	0
0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	0	yksi	yksi	0	s 1	yksi
0	0	0	yksi	yksi	yksi	yksi	0	0	0	0	yksi	yksi	yksi	yksi	0	0	0	0	yksi	s2_ _	yksi
0	0	0	0	0	0	0	yksi	yksi	yksi	yksi	yksi	yksi	yksi	yksi	0	0	0	0	0	s3_ _	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	yksi	yksi	yksi	yksi	yksi	s4_ _	0

Huomaa, että yhdellä virheellä oireyhtymämatriisi on aina binääritietue (vähiten merkitsevä numero ylimmällä rivillä) paikan numerosta, jossa virhe tapahtui. Yllä olevassa esimerkissä oireyhtymämatriisi (01100) vastaa binaarilukua 00110 tai desimaalilukua 6, mikä tarkoittaa, että virhe tapahtui kuudennessa bitissä.

Sovellus

Hamming-koodia käytetään joissakin tallennussovelluksissa, erityisesti RAID 2 :ssa . Lisäksi Hamming-menetelmää on käytetty pitkään ECC -muistissa ja sen avulla voit korjata yksittäiset virheet ja havaita kaksoisvirheet lennossa.

Katso myös

Muistiinpanot

↑ Hamming-koodit - "All About Hi-Tech" . all-ht.ru. Käyttöpäivä: 20. tammikuuta 2016. Arkistoitu alkuperäisestä 15. tammikuuta 2016. (määrätön)

Kirjallisuus

Peterson W., Weldon E. Virheenkorjauskoodit: Per. englannista. Moskova: Mir, 1976, 594 s.
Penin P.E., Filippov L.N. Radiotekniikan tiedonsiirtojärjestelmät. Moskova: Radio ja viestintä, 1984, 256 s.
Blahut R. Virheenhallintakoodien teoria ja käytäntö. Per. englannista. M.: Mir, 1986, 576 s.