Konvolúció (informatika) - Convolution (computer science)

A számítógép-tudomány , különösen a hivatalos nyelv , konvolúció (nevezik zip ) egy olyan funkció, ami leképezi a tuple a szekvenciák egy szekvenciát a sorok . Ez a név zip ered a működés során a cipzár , hogy Kísérőlapokat két korábban különálló szekvenciákat. A fordított függvény a kicsomagolás, amely dekonvolúciót hajt végre.

Példa

Mivel a három szó macska , hal és legyen hol | macska | 3, | hal | 4 és | legyen | a 2. Jelöljük a hal leghosszabb szavának hosszát ; . A konvolúciós a macska , hal , BE ezután 4 tuple elemek: ${\ displaystyle \ ell}$${\ displaystyle \ ell = 4}$

${\ displaystyle (c, f, b) (a, i, e) (t, s, \#) (\#, h, \#)}$

ahol # az eredeti ábécében nem szereplő szimbólum. A Haskell ez csonka legrövidebb szekvencia , ahol : ${\ displaystyle {\ aláhúzás {\ ell}}}$${\ displaystyle {\ aláhúzás {\ ell}} = 2}$

zip3 "cat" "fish" "be"
-- [('c','f','b'),('a','i','e')]

Meghatározás

Legyen Σ ábécé , # szimbólum, amely nem szerepel Σ -ben.

Legyen x ₁ x ₂ ... x _{| x |} , y ₁ y ₂ ... y _{| y |} , z ₁ z ₂ ... z _{| z |} , ... legyen words elemeinek n szava (azaz véges szekvenciája ). Hagyja jelölik a hossza a leghosszabb szót, azaz a maximális | x |, | y |, | z |, .... ${\ displaystyle \ ell}$

Ezeknek a szavaknak a konvolúciója a (Σ ∪ {#}) elemeinek n -tömbjeinek véges sorozata , azaz eleme : ${\ displaystyle ((\ Sigma \ cup \ {\#\})^{n})^{*}}$

${\ displaystyle (x_ {1}, y_ {1}, \ ldots) (x_ {2}, y_ {2}, \ ldots) \ ldots (x _ {\ ell}, y _ {\ ell}, \ ldots)}$,

ahol bármely indexhez i > | w | , a w _i #.

Az x, y, z, ... konvolúcióját konv ( x, y, z, ... ), zip ( x, y, z, ... ) vagy x ⋆ y ⋆ z ⋆ jelöljük ...

A konvolúció fordítottját néha unzip -nek jelölik.

A konvolúciós művelet egyik variációját a következők határozzák meg:

${\ displaystyle (x_ {1}, y_ {1}, \ ldots) (x_ {2}, y_ {2}, \ ldots) \ ldots (x _ {\ aláhúzva {\ ell}}, y _ {\ aláhúzva {\ ell}}, \ ldots)}$

hol van a beviteli szavak minimális hossza. Elkerüli a szomszédos elem használatát , de megsemmisíti a bemeneti szekvenciák azon túl lévő elemeire vonatkozó információkat . ${\ displaystyle {\ aláhúzás {\ ell}}}$${\ displaystyle \#}$${\ displaystyle {\ aláhúzás {\ ell}}}$

Programozási nyelveken

A konvolúciós funkciók gyakran elérhetők programozási nyelveken , amelyeket gyakran zip -nek is neveznek . A Lisp -dialects lehet egyszerűen Térkép a kívánt funkciót át a kívánt listákat, térkép van variadic Lisp ezért lehetséges, hogy tetszőleges számú listákat érv. Példa Clojure -ból :

;; `nums' contains an infinite list of numbers (0 1 2 3 ...)
(def nums (range))
(def tens [10 20 30])
(def firstname "Alice")

;; To convolve (0 1 2 3 ...) and [10 20 30] into a vector, invoke `map vector' on them; same with list
(map vector nums tens)           ; ⇒ ([0 10] [1 20] [2 30])
(map list nums tens)             ; ⇒ ((0 10) (1 20) (2 30))
(map str nums tens)              ; ⇒ ("010" "120" "230")

;; `map' truncates to the shortest sequence; note missing \c and \e from "Alice"
(map vector nums tens firstname) ; ⇒ ([0 10 \A] [1 20 \l] [2 30 \i])
(map str nums tens firstname)    ; ⇒ ("010A" "120l" "230i")

;; To unzip, apply `map vector' or `map list'
(apply map list (map vector nums tens firstname))
;; ⇒ ((0 1 2) (10 20 30) (\A \l \i))

In Common Lisp :

(defparameter nums '(1 2 3))
(defparameter tens '(10 20 30))
(defparameter firstname "Alice")

(mapcar #'list nums tens)
;; ⇒ ((1 10) (2 20) (3 30))

(mapcar #'list nums tens (coerce firstname 'list))
;; ⇒ ((1 10 #\A) (2 20 #\l) (3 30 #\i)) — truncates on shortest list

;; Unzips
(apply #'mapcar #'list (mapcar #'list nums tens (coerce firstname 'list)))
;; ⇒ ((1 2 3) (10 20 30) (#\A #\l #\i))

Nyelvek, mint a Python olyan zip () függvény, régebbi verzió (Python 2 *) engedélyezett feltérképezése Nincs több listákat, hogy hasonló hatást. zip () a * operátorral együtt kibont egy listát:

>>> nums = [1, 2, 3]
>>> tens = [10, 20, 30]
>>> firstname = 'Alice'

>>> zipped = zip(nums, tens)
>>> zipped
[(1, 10), (2, 20), (3, 30)] 

>>> zip(*zipped) # unzip
[(1, 2, 3), (10, 20, 30)]

>>> zipped2 = zip(nums, tens, list(firstname))
>>> zipped2 # zip, truncates on shortest
[(1, 10, 'A'), (2, 20, 'l'), (3, 30, 'i')] 
>>> zip(*zipped2) # unzip
[(1, 2, 3), (10, 20, 30), ('A', 'l', 'i')]

>>> # mapping with `None' doesn't truncate; deprecated in Python 3.*
>>> map(None,nums, tens, list(firstname))
[(1, 10, 'A'), (2, 20, 'l'), (3, 30, 'i'), (None, None, 'c'), (None, None, 'e')]

Haskell van egy eljárás convolving szekvenciák de megköveteli egy adott funkciót minden egyes argumentumainak száma ( zip a két szekvenciát, zip3 három stb), hasonlóan a funkciók csomagolja és unzip3 állnak rendelkezésre unzipping:

-- nums contains an infinite list of numbers [1, 2, 3,...] 
nums = [1..]
tens = [10, 20, 30]
firstname = "Alice"

zip nums tens
-- ⇒ [(1,10),(2,20),(3,30)] — zip, truncates infinite list
unzip $ zip nums tens
-- ⇒ ([1,2,3],[10,20,30]) — unzip

zip3 nums tens firstname
-- ⇒ [(1,10,'A'),(2,20,'l'),(3,30,'i')] — zip, truncates
unzip3 $ zip3 nums tens firstname
-- ⇒ ([1,2,3],[10,20,30],"Ali") — unzip

Nyelvi összehasonlítás

A nyelvek listája a konvolúció támogatása szerint:

Lásd még

• Térkép (magasabb rendű funkció)

Hivatkozások

Ez a cikk a PlanetMath konvolúciójának anyagát tartalmazza , amely a Creative Commons Nevezd meg/Share-Alike licenc alapján licencelt .