Looginen toiminta yksinomaan tai. Loogiset perustoiminnot

Käytännössä yleisimmin käytetyt kaksisyötteiset elementit ovat "exclusive OR". Kuvassa Kuvassa 1 on tavanomainen graafinen merkintä elementistä ilman inversiota ja sen tilataulukko. Yksinkertaisesti sanottuna tämän elementin olemus tiivistyy seuraavaan: lähtösignaali ilmestyy vain, kun tulojen loogiset tasot eivät ole samat.

Kaavio pulssin reunan ja rajan tunnistamiseksi

Tässä piirissä käytetään kolmea XOR-porttia viivyttämään pulsseja. DD1.4 - summaus. Lähtöpulsseilla on vakaat etureunat ja laskevat reunat. Kunkin lähtöpulssin kesto on kolminkertainen kunkin kolmen elementin kytkentäviiveeseen. Lähtöpulssien reunojen välinen aikaväli on yhtä suuri kuin tulopulssin kesto. Tämä laite myös kaksinkertaistaa tulosignaalin taajuuden.

On toinenkin mielenkiintoinen ominaisuus nimeltä "Exclusive OR". Jos johonkin tuloon syötetään vakio "0", elementin lähdössä oleva signaali toistaa tulosignaalin, ja jos vakio "0" muutetaan vakioksi "1", lähtösignaali olla jo tulosignaalin inversio.

Joskus tulee välttämättömäksi hankkia "yksinomainen TAI"-portti yksittäisistä standardeista loogisista porteista. Esimerkki on "exclusive OR" -elementtipiiri, joka on toteutettu neljälle 2-AND-NOT-elementille. Kuvassa 3 on XOR-piiri sen neljässä tilassa. Tämä näyttää kaikki mahdolliset logiikkatasot jokaisessa käytetyssä 2-NAND-portissa.

Tällaiset elementit sisältyvät kaavioon. Tässä piirissä "Exclusive OR" -elementti on valmistettu neljästä 2-AND-NOT -elementistä, jotka sisältyvät yhteen K561LA7-mikropiirin pakkaukseen.

Diskreetti signaaligeneraattori erotaajuudella

Ohjainpiiri on esitetty kuvassa 4. Tässä eksklusiivinen OR-logiikkaelementti on myös toteutettu neljälle 2-AND-NOT-elementille.

Suorakaiteen muotoiset pulssit putoavat muotoilijan tuloihin 1 ja 2 (katso kaaviot 1 ja 2), jotka eroavat toistotaajuudesta. Loogisiin elementteihin DD1.1-DDI.4 perustuva solmu kertoo nämä signaalit. Lähtöpulssisignaali (kuvaaja 3) elementistä DD1.4 syötetään integrointipiiriin R3, C1, joka muuntaa sen kolmiomaiseksi signaaliksi (kuvaaja 4), jonka taajuus on yhtä suuri kuin tulosignaalien taajuuksien ero, ja op. -amp DA1 muuntaa vastaanotetun signaalin neliöaaltoksi (katso aikataulu 5). Vastus R1 säätelee lähtösignaalin positiivisten ja negatiivisten puoliaaltojen kestoa. Erittäin mielenkiintoinen kaava. Radiosuunnittelijalla on ajateltavaa. Esimerkiksi kolmannessa kaaviossa esitetty signaali on siniaallon PWM-signaali.
Tietenkin "yksinomaisten OR" -elementtien käyttöalue on paljon laajempi. Olen esittänyt täällä mielestäni radioamatööreille mielenkiintoisemman.

Tunnisteet: C-bittioperaatiot, bittioperaatiot, bittien yhteenlasku, bittien kertolasku, bittisiirto vasemmalle, bittisiirto oikealle

Johdanto

C-kieltä kutsutaan joskus makrokokoonpanoksi, koska se on affiniteetti laitteistoon. Jos et käytä optimointia, voit jopa arvioida karkeasti, mihin kokoonpanokielen rakenteisiin ohjelmakoodi muunnetaan. Kielen yksinkertaisuus ja minimalismi (kielen yksinkertaisuutta ei pidä sekoittaa kielen ohjelmoinnin yksinkertaisuuteen) on johtanut siihen, että monilla alustoilla C on edelleen ainoa korkean tason ohjelmointikieli. Ilman yleiskuvaa bittikohtaisista operaatioista kielen oppiminen olisi tietysti epätäydellistä.

Bittikohtaiset operaatiot, kuten nimestä voi päätellä, antavat sinun toimia suoraan bittien kanssa. Suuri joukko esimerkkejä bittikohtaisten operaatioiden käytöstä löytyy esimerkiksi Henry Warrenin kirjasta "Algoritmic Tricks for Programmers". Tässä tarkastellaan vain itse operaatioita ja primitiivisiä algoritmeja.

Bittikohtaisesti JA, TAI, EI, XOR

Muistutan ensin, että loogiset operaatiot JA, TAI, poissulkevat OR ja EI voidaan kuvata totuustaulukoiden avulla

Bittikohtaisissa operaatioissa bittiarvoa 1 käsitellään loogisena tosina ja 0:na epätosi. Bittikohtainen AND (operaattori &) ottaa kaksi numeroa ja kertoo loogisesti vastaavat bitit. Jos esimerkiksi kerrot loogisesti 3:lla 8, saat 0

Char a = 3; char b = 8; char c = a&b; printf("%d", c);

Koska binäärimuodossa 3 yksitavuisena kokonaislukuna edustaa

Muuttujan c ensimmäinen bitti on yhtä suuri kuin luvun a ensimmäisen bitin ja luvun b ensimmäisen bitin looginen tulo. Ja niin edelleen jokaisesta bitistä.

00000011
00001000
↓↓↓↓↓↓↓↓
00000000

Vastaavasti lukujen 31 ja 17 bittitulo antaa luvun 17, koska 31 on 00011111 ja 17 on 00010001

00011111
00010001
↓↓↓↓↓↓↓↓
00010001

Numeroiden 35 ja 15 bittitulo on 3.

00100011
00001111
↓↓↓↓↓↓↓↓
00000011

Bittikohtainen TAI-operaatio (operaattori |) toimii samalla tavalla, paitsi että se summaa loogisesti vastaavat numerobitit ilman siirtoa.

Esimerkiksi,

Char a = 15; char b = 11; merkki c = a | b; printf("%d", c);

tulostaa 15, koska 15 on 00001111 ja 11 on 00001011

00001111
00001011
↓↓↓↓↓↓↓↓
00001111

Bittikohtainen TAI numeroille 33 ja 11 palauttaa 43, koska 33 on 00100001 ja 11 on 00001011

00100001
00001011
↓↓↓↓↓↓↓↓
00101011

Bittinegataatio (operaattori ~) ei toimi yhdelle bitille, vaan koko luvulle. Käännösoperaattori muuttaa epätosi arvoksi tosi ja tosi epätosi jokaiselle bitille. Esimerkiksi,

Char a = 65; char b = ~a; printf("%d", b);

Se tulostaa -66, koska 65 on 01000001 ja inversio antaa 10111110

joka on yhtä suuri kuin -66. Muuten, tässä on algoritmi luvun tekemiseksi negatiiviseksi: löytääksesi luvun täydentävän koodin, sinun on käännettävä se ja lisättävä siihen yksi.

Char a = 107; char b = ~a + 1; printf("a = %d, -a = %d", a, b);

Yksinomainen OR (^-operaattori) käyttää bittikohtaista XOR-operaatiota. Esimerkiksi numeroille

Char a = 12; char b = 85; char c = a^b; printf("%d", c);

89 tulostetaan, koska a on 00001100 ja b on 01010101. Tuloksena saamme 01011001

Joskus loogiset operaattorit && ja || sekoitetaan &- ja |-operaattoreihin. Tällaisia ​​virheitä voi esiintyä koodissa melko pitkään, koska tällainen koodi toimii joissakin tapauksissa. Esimerkiksi luvuille 1 ja 0. Mutta koska C:ssä mikä tahansa nollasta poikkeava arvo on tosi, niin lukujen 3 ja 4 bittikohtainen kertolasku palauttaa 0:n, vaikka loogisen kertolaskun pitäisi palauttaa tosi.

Int a = 3; int b = 4; printf("a & b = %d\n", a & b); //tulostaa 0 printf("a && b = %d\n", a && b);//tulostaa ei 0 (tarkemmin 1)

Bittisiirtotoiminnot

Vaihtotoimintoja on kaksi - bittisiirto vasemmalle (operaattori<<) и битовый сдвиг вправо (оператор >>). Bittisiirto oikealle siirtää luvun bittejä oikealle ja lisää nollia vasemmalle. Bitin siirto vasemmalle tekee päinvastoin: se siirtää bittejä vasemmalle ja lisää nollia oikealle. Numeron ylittävät bitit hylätään.

Siirrä esimerkiksi numeroa 5 vasemmalle 2 paikkaa

00000101 << 2 == 00010100

Siirrä numeroa 19 oikealle 3 paikkaa

00010011 >> 3 == 00000010

Riippumatta arkkitehtuurista (big-endian, tai little-endian tai middle-endian), binääriluvut esitetään vasemmalta oikealle, merkittävimmästä bitistä vähiten merkitsevään. Bittien siirto vaatii kaksi operandia – siirrettävän luvun ja siirrettävien bittien määrän.

Int a = 12; printf("%d<< 1 == %d\n", a, a << 1); printf("%d << 2 == %d\n", a, a << 2); printf("%d >> 1 == %d\n", a, a >> 1); printf("%d >> 2 == %d\n", a, a >> 2);

Koska siirto oikealle (>>) lisää nollia vasemmalle, kokonaislukujen toiminto vastaa kokonaisluvun jakamista puolikkaalla ja siirto vasemmalle vastaa kertomista kahdella. Bittisiirtoa on mahdotonta suorittaa kelluvalle pistenumero ilman nimenomaista tyyppiä. Tämä johtuu siitä, että C:llä ei ole määritetty liukulukuesitystä. Voit kuitenkin siirtää kellukkeen int-kohtaan, siirtää sen ja laittaa sen takaisin

Float b = 10,0f; float c = (kelluke) (*((signed int*)&b) >> 2); printf("%.3f >> 2 = %.3f", b, c);

Mutta tietenkään emme saa 5.0f, vaan täysin eri numeroa.

Vaihtooperaattoreissa on se, että ne voivat käyttäytyä eri tavalla etumerkittyjen ja etumerkittömien numeroiden kanssa kääntäjästä riippuen. Itse asiassa negatiivinen luku sisältää yleensä yhden etumerkkibitin. Kun siirrymme vasemmalle, se voi kadota ja numerosta tulee positiivinen. Kääntäjä voi kuitenkin saada muutoksen pysymään vakiona etumerkissä ja noudattamaan erilaisia ​​sääntöjä. Sama pätee oikeaan vaihteeseen.

Signed int ua = 12; signed int sa = -11; printf("ua = %d, ua >> 2 = %d\n", ua, ua >> 2); printf("sa = %d, sa >> 2 = %d\n", sa, sa >> 2); printf("(allekirjoittamaton) sa = %u, sa >> 2 = %u\n", sa, sa >> 2); printf("sa = %d, ((allekirjoittamaton) sa) >> 2 = %d", sa, ((allekirjoittamaton) sa) >> 2);

Tässä tapauksessa ensimmäisen vuoron aikana kaikki toimii tarkoitetulla tavalla, koska numero on allekirjoittamaton. Toisessa tapauksessa VSE2013-kääntäjä jättää merkin. Jos kuitenkin katsot tämän luvun esitystä etumerkittömänä, siirto tapahtuu eri sääntöjen mukaan ja vasemmanpuoleisin bitti säilyy. Viimeisellä rivillä, jos muunnamme etumerkillisen luvun etumerkittömäksi luvuksi, tapahtuu tavallinen muutos, ja tuloksena saadaan positiivinen luku.

Bitti- ja siirtooperaattorit eivät muuta luvun arvoa, vaan palauttavat uuden. Ne, kuten aritmeettiset operaattorit, voivat olla osa monimutkaista tehtävää

Int a = 10; int b = 1; a >>= 3; a ^= (b<< 3); и т.д.

Esimerkkejä

1. Kirjoitetaan funktioita, joiden avulla voit määrittää ja muuttaa luvun tietyn bitin

Käytämme loogista kertolaskua saadaksemme selville, mikä bitti (1 vai 0) on paikassa n.

Olkoon numero 9

00001001

Meidän on selvitettävä, onko bitti asetettu asentoon 3 (alkaen nollasta). Voit tehdä tämän kertomalla sen luvulla, jonka kaikki bitit ovat nollia kolmatta lukuun ottamatta:

00001001 & 00001000 = 00001000

Nyt selvitetään bitin arvo kohdassa 6

00001001 & 01000000 = 00000000

Siten, jos saamme vastauksen, joka on yhtä suuri kuin nolla, haluttu paikka on nolla, muuten yksi. Saadaksesi luvun, joka koostuu nollista ja yksi bitti halutussa paikassa, siirrä 1 tarvittavalla määrällä bittejä vasemmalle.

#sisältää #sisältää #sisältää int tarkistusbitti(const int arvo, const int sijainti) ( int tulos; if ((arvo & (1<< position)) == 0) { result = 0; } else { result = 1; } return result; } void main() { int a = 3; size_t len = sizeof(int) * CHAR_BIT; size_t i; for (i = 0; i < len; i++) { printf("%d", checkbit(a, i)); } _getch(); }

Huomaa, että funktiossa ehto kirjoitetaan näin

(arvo & (1<< position)) == 0

Koska ilman sulkuja lasketaan ensin yhtäläisyys nollaan ja vasta sitten suoritetaan kertolasku.

Arvo&(1<< position) == 0

Toimintoa voidaan yksinkertaistaa

Int tarkistusbitti(const int value, const int position) ( return ((arvo & (1<< position)) != 0); }

Funktio, joka asettaa n:nnessä paikassa olevan bitin ykköseksi.

Tiedetään, että minkä tahansa bitin looginen lisäys, jossa on 1, on yhtä suuri kuin 1. Joten n:nnen bitin asettamiseksi sinun on loogisesti lisättävä luku ykkösellä, jossa kaikki bitit paitsi vaadittu yksi on yhtä suuri kuin nolla. Kuinka saada tällainen numero, on jo keskusteltu.

Int setbit(const int value, const int position) ( return (arvo | (1<< position)); }

Funktio, joka asettaa n:nnen kohdan bitin nollaan.

Tätä varten on välttämätöntä, että luvun kaikki bitit, paitsi n:s, pysyvät muuttumattomina. Kerrotaan luku yhdellä, jossa kaikki bitit ovat yhtä suuria kuin yksi, paitsi bitti numeroitu n. Esimerkiksi

0001011 & 1110111 = 0000011

Tällaisen maskin saamiseksi luomme ensin numeron, jossa on nollia ja yksi, ja sitten käännämme sen.

Int unsetbit(const int value, const int position) ( return (arvo & ~(1<< position)); }

Funktio, joka kääntää n:nnen bitin arvon.

Tätä varten käytämme eksklusiivista tai funktiota: käytä XOR-toimintoa numeroon, joka koostuu vain nollia ja yhdestä halutun bitin tilalla.

Int switchbit(const int value, const int position) ( return (arvo ^ (1<< position)); }

Tutkimus

#sisältää #sisältää #sisältää int tarkistusbitti(const int value, const int position) ( return ((arvo & (1<< position)) != 0); } int setbit(const int value, const int position) { return (value | (1 << position)); } int unsetbit(const int value, const int position) { return (value & ~(1 << position)); } int switchbit(const int value, const int position) { return (value ^ (1 << position)); } void printbits(int n) { //CHAR_BIT опеределён в библиотеке limits.h //и хранит число бит в байте для данной платформы size_t len = sizeof(int)* CHAR_BIT; size_t i; for (i = 0; i < len; i++) { printf("%d", checkbit(n, i)); } printf("\n"); } void main() { int a = 3; size_t len = sizeof(int) * CHAR_BIT; size_t i; printbits(a); a = setbit(a, 5); printbits(a); a = unsetbit(a, 5); printbits(a); a = switchbit(a, 11); printbits(a); a = switchbit(a, 11); printbits(a); _getch(); }

Bit liput

Katsotaanpa synteettistä esimerkkiä. Olkoon meillä kolme loogista muuttujaa, ja meidän on tulostettava tietty arvo, joka riippuu kaikista näistä muuttujista kerralla. Ilmeisesti vaihtoehtoja voi olla 2 tai 3. Kirjoitetaan tämä ehto haaran muodossa:

#sisältää int main() ( etumerkitön merkki a, b, c; a = 1; b = 0; c = 0; if (a) ( if (b) ( if (c) ( printf("tosi tosi tosi"); ) else ( printf("tosi tosi epätosi"); ) ) else ( if (c) ( printf("tosi väärä tosi"); ) else ( printf("tosi väärä väärä"); ) ) else ( if (b) ( if (c) ( printf("väärin tosi tosi"); ) else ( printf("väärin tosi epätosi"); ) ) else ( if (c) ( printf("false false true"); ) else ( printf( "false false false");

Meillä on 8 haaraa. Oletetaan, että nyt meidän on lisättävä yksi ehto. Sitten haarojen määrä kaksinkertaistuu, ja ohjelmasta tulee entistä vaikeampi ymmärtää ja virheenkorjaus. Kirjoitetaan esimerkki uudelleen.

Jos jokaista loogista arvoamme siirretään sen bittien lukumäärällä vasemmalle ja lisätään loogisesti, saamme ainutlaatuisen bittiyhdistelmämme a, b ja c arvoista riippuen:

#sisältää #sisältää void printbits (int n) ( int i; for (i = CHAR_BIT - 1; i >= 0; i--) ( printf("%d", (n & (1)<< i)) != 0); } printf("\n"); } int main() { unsigned char a, b, c; unsigned char res; a = 1; b = 0; c = 0; res = c | b << 1 | a << 2; printbits(res); a = 0; b = 1; c = 1; res = c | b << 1 | a << 2; printbits(res); a = 1; b = 0; c = 1; res = c | b << 1 | a << 2; printbits(res); _getch(); return 0; }

Käytetään tätä lähestymistapaa ongelmaamme ja korvataan haarautuminen kytkimellä:

#sisältää int main() ( etumerkitön merkki a, b, c; etumerkitön merkki; a = 1; b = 0; c = 0; res = c | b<< 1 | a << 2; switch (res) { case 0b00000000: printf("false false false"); break; case 0b00000001: printf("false false true"); break; case 0b00000010: printf("false true false"); break; case 0b00000011: printf("false true true"); break; case 0b00000100: printf("true false false"); break; case 0b00000101: printf("true false true"); break; case 0b00000110: printf("true true false"); break; case 0b00000111: printf("true true true"); break; } _getch(); return 0; }

Tätä menetelmää käytetään hyvin usein toimintovaihtoehtojen määrittämiseen eri ohjelmointikielillä. Jokaisella lipulla on oma yksilöllinen nimensä, ja niiden yhdistetty arvo on kaikkien käytettyjen lippujen looginen summa. Esimerkiksi fcntl-kirjasto.

Operaatio poissulkeva TAI (ei-ekvivalenssi, additio modulo two) on merkitty symbolilla ja eroaa loogisesta TAI vain kun A=1 ja B=1.

Siten kahden lauseen X1 ja X2 eroa kutsutaan lauseeksi Y, joka on tosi silloin ja vain, jos toinen näistä väitteistä on tosi ja toinen epätosi.

Tämän toiminnon määritelmä voidaan kirjoittaa totuustaulukon muotoon (taulukko 6):

Taulukko 6 – "EXCLUSIVE OR" -toiminnon totuustaulukko

Kuten taulukosta 6 voidaan nähdä, elementin toiminnan logiikka vastaa sen nimeä.

Tämä on sama "OR"-elementti yhdellä pienellä erolla. Jos arvo molemmissa tuloissa on yhtä suuri kuin looginen, "EXCLUSIVE OR" -elementin lähtö, toisin kuin "OR"-elementissä, ei ole yksi, vaan nolla.

EXCLUSIVE OR -toiminto itse asiassa vertaa kahta binäärinumeroa osuman saamiseksi.

Jokaista loogista konnektiivia pidetään loogisten lauseiden toimintona ja sillä on oma nimi ja nimitys (taulukko 7).

Taulukko 7 - Loogiset perusoperaatiot

1. Loogisten operaatioiden järjestys monimutkaisessa loogisessa lausekkeessa

Inversion, konjunktion ja disjunktion loogisten operaatioiden järjestelmä mahdollistaa mielivaltaisen monimutkaisen loogisen lausekkeen rakentamisen.

Loogisen lausekkeen arvoa laskettaessa otetaan käyttöön tietty loogisten toimintojen järjestys.

1. Kääntäminen.

2. Konjunktio.

3. Disjunktio.

4. Implisaatio.

5. Vastaavuus.

Sulkuja käytetään muuttamaan määritettyä toimintojen järjestystä.

1. Loogiset lausekkeet ja totuustaulukot

   1. Boolen lausekkeet

Jokainen yhdistelmälause voidaan ilmaista kaavan (looginen lauseke) muodossa, joka sisältää loogiset muuttujat, ilmaisevat lausunnot ja merkkejä loogisista operaatioista, ilmaisevat loogisia toimintoja.

Yhdistelmälausekkeen kirjoittamiseksi loogisen lausekkeen muodossa muodollisella kielellä (logiikan algebran kielellä), yhdistetyssä lauseessa on tarpeen tunnistaa yksinkertaiset lausunnot ja loogiset yhteydet niiden välillä.

Kirjoitetaan loogisen lausekkeen muodossa yhdistelmälause ”(2·2=5 tai 2∙2=4) ja (2∙2≠5 tai 2∙ 2 ≠4)".

Analysoidaan yhdistelmälausetta. Se sisältää kaksi yksinkertaista lausuntoa:

A = "2 2 = 5" - epätosi (0),

B = "2 2 = 4" - tosi (1).

Sitten yhdistelmälause voidaan kirjoittaa seuraavassa muodossa:

«( AtaiIN) ja (Ā taiIN)».

Nyt sinun on kirjoitettava lausunto loogisen lausekkeen muodossa ottaen huomioon loogisten toimintojen järjestys. Loogisia operaatioita suoritettaessa määritetään seuraava suoritusjärjestys:

inversio, konjunktio, disjunktio.

Sulkeilla voidaan muuttaa määritettyä järjestystä:

F = (AvIN) & (Ā vIN).

Yhdistelmäväitteiden totuus tai vääryys voidaan määrittää puhtaasti muodollisesti, lausealgebran lakien ohjaamana, viittaamatta lauseiden semanttiseen sisältöön.

Korvataan loogisten muuttujien arvot loogiseen lausekkeeseen ja loogisten perusoperaatioiden totuustaulukoiden avulla saadaan loogisen funktion arvo:

F= (A v B) & ( Ā v B) = (0 v 1) & (1 v 0) = 1 & 1 = 1.

Totuustaulukot

Taulukoita, joissa loogiset toiminnot heijastavat monimutkaisten lauseiden laskelmien tuloksia alkuperäisten yksinkertaisten lauseiden eri arvoille, kutsutaan totuustaulukoiksi.

Yksinkertaiset lauseet merkitään muuttujilla (esimerkiksi A ja B).

Totuustaulukoita rakennettaessa on suositeltavaa noudattaa tiettyä toimintosarjaa:

on tarpeen määrittää totuustaulukon rivien lukumäärä. Se on yhtä suuri kuin loogiseen lausekkeeseen sisältyvien loogisten muuttujien arvojen mahdollisten yhdistelmien lukumäärä. Jos loogisten muuttujien määrä on yhtä suuri p, Että:

rivien määrä = 2 n .

Meidän tapauksessamme looginen funktio

siinä on 2 muuttujaa ja siksi totuustaulukon rivien lukumäärän on oltava 4;

on tarpeen määrittää totuustaulukon sarakkeiden lukumäärä, joka on yhtä suuri kuin loogisten muuttujien lukumäärä plus loogisten operaatioiden lukumäärä.

Meidän tapauksessamme muuttujia on kaksi: A ja B, ja loogisten operaatioiden määrä on viisi (taulukko 8), eli totuustaulukon sarakkeiden lukumäärä on seitsemän;

on tarpeen rakentaa totuustaulukko tietyllä määrällä rivejä ja sarakkeita, nimetä sarakkeet ja syöttää taulukkoon mahdolliset alkuperäisten loogisten muuttujien arvojoukot;

totuustaulukko on täytettävä sarakkeittain suorittamalla loogiset perusoperaatiot vaaditussa järjestyksessä ja niiden totuustaulukoiden mukaisesti.

Voimme nyt määrittää Boolen funktion arvon mille tahansa Boolen muuttujan arvojoukolle.

Taulukko 8 – Loogisen funktion totuustaulukko

Ilmaistaan ​​puhekuviolla "joko... tai..." Yhdistelmälause "joko A tai B" on tosi, kun joko A tai B on tosi, mutta ei molempia; muuten yhdistelmälause on väärä.

Ne. tulos on tosi (yhtä kuin 1), Jos A ei ole yhtä suuri kuin B (A≠B).

Tätä operaatiota verrataan usein disjunktioon, koska ne ovat ominaisuuksiltaan hyvin samankaltaisia ​​ja molemmilla on yhtäläisyyksiä arkipuheen konjunktion "tai" kanssa. Vertaa näiden toimintojen sääntöjä:

1. totta jos totta tai , tai molemmat kerralla.

2. totta, jos totta tai, Mutta Ei molemmat kerralla.

Toiminta sulkee pois jälkimmäinen vaihtoehto ("molemmat kerralla") ja tästä syystä kutsutaan yksinoikeudeksi "TAI". Epäselvyys luonnollinen kieli tarkoittaa, että konjunktiota "tai" voidaan käyttää molemmissa tapauksissa.

5. Implikaatio (looginen seuraus) muodostetaan yhdistämällä kaksi lausuntoa yhdeksi käyttämällä puhehahmoa "jos ... niin ...".

Tallennus: A®B

Implikaatiooperaatiolla muodostettu yhdistelmäväite on epätosi, jos ja vain jos väärä johtopäätös (toinen väite) seuraa tosi premissistä (ensimmäinen väite).

Ne. jos 1 tarkoittaa 0, niin tulos on 0, muissa tapauksissa - 1.

Esimerkiksi lause "Jos luku on jaollinen 10:llä, niin se on jaollinen 5:llä" on totta, koska sekä ensimmäinen että toinen väite ovat totta.

Väite "Jos luku on jaollinen 10:llä, niin se on jaollinen kolmella" on virheellinen, koska väärä johtopäätös tehdään todellisesta lähtökohdasta.

"Tämä nelikulmio on neliö" (A) Ja "Ympyrä voidaan rajata tietyn nelikulmion ympärille" (IN). Sitten yhdistelmälause kuuluu seuraavasti "Jos annettu nelikulmio on neliö, sen ympärille voidaan piirtää ympyrä."

Tavallisessa puheessa konnektiivi "jos... sitten" kuvaa väitteiden välistä syy-seuraussuhdetta. Mutta loogisissa operaatioissa lauseiden merkitystä ei oteta huomioon. Vain niiden totuus tai valhe otetaan huomioon. Siksi sisällöltään täysin riippumattomien lausuntojen muodostamien implikaatioiden "merkittämättömyydestä" ei pidä joutua nolostumaan. Esimerkiksi näin: "Jos Yhdysvaltain presidentti on demokraatti, niin Afrikassa on kirahveja", "jos vesimeloni on marja, huoltoasemalla on bensiiniä."

6. Ekvivalenssi (looginen yhtäläisyys, ~ º Û) muodostetaan yhdistämällä kaksi lausetta yhdeksi käyttämällä puhehahmoa "...jos ja vain jos..."

Ekvivalenssioperaatiolla muodostettu yhdistelmälause on tosi silloin ja vain, jos molemmat lauseet ovat samanaikaisesti joko epätosi tai tosi.

Esimerkiksi lauseet "Tietokone voi laskea, jos ja vain jos se on päällä" ja "Tietokone ei voi laskea, jos ja vain jos se ei ole päällä" ovat tosia, koska molemmat yksinkertaiset lauseet ovat yhtä aikaa tosia.

Totuustaulukot

Jokaiselle yhdistetylle lauseelle (loogiselle funktiolle) on mahdollista rakentaa totuustaulukko, joka määrittää sen totuuden tai virheellisyyden kaikille mahdollisille yksinkertaisten lauseiden alkuarvojen yhdistelmille.

Totuustaulukko on logiikkapiirin (operaation) taulukkoesitys, jossa luetellaan kaikki mahdolliset tulosignaalien (operandien) totuusarvojen yhdistelmät sekä lähtösignaalin totuusarvo (operaation tulos) jokaiselle näistä yhdistelmistä.

Kuvataanpa yllä käsiteltyjä loogisia operaatioita totuustaulukossa:

Propositioalgebrassa kaikki loogiset funktiot voidaan loogisilla muunnoksilla pelkistää kolmeen perusfunktioon: looginen yhteenlasku, looginen kertolasku ja looginen negaatio.

Osoitetaan, että implikaatiooperaatio A®B vastaa loogista lauseketta:

Yksinkertaisimmat loogiset operaatiot kuuluvat kaksiarvoiseen logiikkaan. Niitä on 4: "EI", "JA", "OR", "XOR". Myös erilaisia ​​symboleja ("~", "&" jne.) käytetään osoittamaan näitä toimintoja.

Kun kirjoitetaan loogisia kaavoja, sanojen "tosi" ja "epätosi" sijasta käytetään yleensä standardeja kansainvälisiä merkintöjä:
"Tosi" sijaan he kirjoittavat: tosi, T, t, 1.
Sanan "false" sijaan he kirjoittavat: false, F, f, 0.

"EI"

"EI"-toiminto muuntaa tosi epätosi ja epätosi tosi:

EI totta = epätosi
EI väärin = totta

Tällä toiminnolla on useita muita nimiä: "looginen EI", "negatio", "looginen negaatio", "inversio", "looginen inversio". Kansainvälisissä nimityksissä "EI" kirjoitetaan "NOT" sijaan.

Luonnollisella kielellä tämä operaatio vastaa sanojen "ei ole totta, että..." lisäämistä lauseen alkuun. Esimerkiksi:

"EI"-operaation käyttäminen lauseeseen (1):

"Ei ole totta, että Surkov on minulle velkaa." (2)

Jos väite (1) on epätosi, niin väite (2) on tosi. Jos väite (2) on epätosi, niin väite (1) on tosi.

Ei ole vaikeaa ymmärtää, että sanan "EI" kaksoiskäyttö palauttaa meidät edelliseen totuuteen.

"Ei ole totta, ei ole totta, että Surkov on minulle velkaa." (3)

Väitteen (3) totuus on aina sama kuin väitteen (1) totuus.

"JA"

JA-operaatiota sovelletaan kahteen lauseeseen. Sen tulos on "tosi" vain, jos molemmat väitteet ovat tosi (muuten "false"):

false JA false = false
epätosi JA tosi = epätosi
tosi ja epätosi = epätosi
totta JA totta = totta

Tällä operaatiolla on useita muita nimiä: "looginen AND", "konjunktio", "looginen kertolasku". Kansainvälisissä nimityksissä kirjoitetaan "I":n sijaan "JA".

Luonnollisella kielellä tämä operaatio vastaa konjunktion "ja" lisäämistä lauseiden väliin. Esimerkiksi:

"Surkov on minulle velkaa." (1)
"Petrov on minulle velkaa." (2)

"AND"-operaation soveltaminen lauseisiin (1) ja (2):

"Surkov on minulle velkaa, ja Petrov on minulle velkaa." (3)

Tätä lausetta voidaan lyhentää säilyttäen samalla merkitys:

"Surkov ja Petrov ovat minulle velkaa." (3)

Väite (3) on tosi vain, jos molemmat väitteet (1) ja (2) ovat tosia. Jos ainakin yksi niistä on epätosi, myös tulos on väärä. Jos molemmat ovat vääriä, niin ovat nekin.

Eli jos Petrov ei ollut minulle velkaa, vaan vain Surkov, niin väite (3) ei ole "puolitotuus" tai "puolivalhe", vaan se on yksinkertaisesti valhe.

"TAI"

TAI-toimintoa sovelletaan kahteen lauseeseen. Sen tulos on "tosi", jos vähintään yksi väite on tosi (muuten "false"):

false TAI false = false
epätosi TAI tosi = tosi
tosi TAI epätosi = tosi
tosi TAI tosi = tosi

Tällä toiminnolla on useita muita nimiä: "looginen TAI", "sisältää TAI", "disjunktio", "looginen lisäys". Kansainvälisissä nimityksissä kirjoita "OR" sijaan "OR".
Luonnollisella kielellä tämä operaatio vastaa konjunktion "tai" lisäämistä lauseiden väliin, mutta... ei aina (katso alla "XOR"-operaatiosta). Esimerkiksi:

"Haluan jotain juotavaa." (1)
"Haluan syödä." (2)

OR-operaation soveltaminen lauseisiin (1) ja (2):

"Haluan juoda tai haluan syödä." (3)

Venäjän kielellä se kuulostaa oikealta, mutta kömpelöltä, ja tätä lausetta voidaan lyhentää säilyttäen sama merkitys:

"Haluan juoda tai syödä." (3)

Väite (3) on tosi, kun vähintään toinen väitteistä (1) ja (2) on tosi tai molemmat ovat mahdollisia. Jos molemmat väitteet ovat vääriä, myös tulos on väärä.

Eli jos olen nälkäinen, mutta en janoinen, väite (3) on totta. Jos en inhoa ​​sekä syömistä että juomista, väite (3) on myös totta. Se on väärin, kun en halua toista enkä toista.

"XOR"

XOR-operaatiota sovelletaan kahteen lauseeseen. Sen tulos on "tosi", jos täsmälleen yksi lauseista on tosi (muuten "false"):

false XOR false = false
false XOR tosi = tosi
tosi XOR false = tosi
tosi XOR tosi = epätosi

Tällä toiminnolla on useita muita nimiä: "exclusive OR", "addition modulo 2", "Looginen lisäys modulo 2". "XOR" on kansainvälinen nimitys, ei ole olemassa yleisesti hyväksyttyä "venäläistä" analogia.

Luonnollisella kielellä tämä operaatio vastaa konjunktion "tai" lisäämistä lausekkeiden väliin - aivan kuten "OR"-operaation tapauksessa. Esimerkiksi:

"Aion pyytää korotusta." (1)
"Yritän säästää rahaa." (2)

"XOR"-operaation soveltaminen lauseisiin (1) ja (2):

"Aion pyytää korotusta tai yritän säästää rahaa." (3)

Lyhennettynä:

"Pyydän korotusta tai yritän säästää rahaa." (3)

Väite (3) on tosi, jos täsmälleen yksi lauseista (1) ja (2) on tosi. Jos en aio pyytää korotusta tai säästää, lause on väärä. Tarkoitin myös, että en aio tehdä molempia yhtä aikaa.

Huomaa ero OR- ja XOR-operaatioiden välillä. Se koostuu vain viimeisestä säännöstä:

tosi TAI tosi = tosi
tosi XOR tosi = epätosi

Luonnollisessa kielessä molempia operaatioita edustaa sama konjunktio "tai". Tämä on esimerkki luonnollisen kielen epäselvyydestä. Jos muistat, homonyymeillä ja moniselitteisillä sanoilla voi olla useampi kuin yksi merkitys. Konjunktio "tai" on juuri sitä: sillä on kaksi mahdollista merkitystä. Ensimmäinen ilmaistaan ​​loogisella operaatiolla "OR", toinen - loogisella operaatiolla "XOR".

Englannissa on samat ongelmat: konjunktiolla "tai" on samat kaksi merkitystä. Mutta se oli helpompaa muinaisille roomalaisille, koska latinassa on kaksi eri sanaa: "vel" (OR-toiminto) ja "aut" (XOR-toiminto).

Koska ero OR:n ja XOR:n välillä on pieni (vain viimeinen sääntö), erolla ei joskus ole väliä. Joskus voit arvata, mitä intonaatiolla tai kontekstilla tarkoitetaan. Joskus ei ole mahdollista määrittää tarkkaa merkitystä.