WEBVTT

00:01.950 --> 00:09.330
È possibile creare una matrice che è effettivamente una matrice di colonne e righe una matrice.

00:09.420 --> 00:17.400
Quando dichiariamo un array, fondamentalmente dichiariamo un array con una riga e per quanto siano larghe molte colonne,

00:17.410 --> 00:18.330
lo fai.

00:18.330 --> 00:24.480
Quindi diciamo che ho bisogno di un array con tre diversi lotti di quattro numeri diversi.

00:24.480 --> 00:31.230
Sarebbe una matrice di tre righe e quattro colonne scritte che notano un foglio di calcolo che possiamo immaginare

00:31.230 --> 00:33.790
e capire che sarebbe simile a questo.

00:34.050 --> 00:38.270
Posso creare questo batch con una dichiarazione come questa.

00:42.980 --> 00:46.880
Se ti aiuta a visualizzarlo.

00:46.880 --> 00:50.720
Questo è anche un modo valido di scrivere lo

00:53.650 --> 01:01.190
stesso codice, quindi nel mio formato di foglio di calcolo ho incluso l'indice di array di ciascun elemento.

01:01.260 --> 01:04.530
Ricorda solo che sono indicizzati

01:08.370 --> 01:13.920
0, quindi ho dichiarato tre righe e quattro colonne.

01:13.920 --> 01:22.990
Ho tre gruppi ciascuno contenente quattro numeri in modo da accedere al terzo elemento nel secondo gruppo

01:23.410 --> 01:32.990
altrimenti noto come terza colonna nella seconda riga che potrei bloccare e caricare in una variabile come questa.

01:33.140 --> 01:37.220
Ricorda 0 indicizzato per noi per dare l'offset di riga.

01:37.250 --> 01:39.110
Quindi l'offset della colonna.

01:39.110 --> 01:46.800
Quindi, dopo questa istruzione, il numero aggiuntivo sarebbe uguale a 0 quando lo recuperava dall'array.

01:47.030 --> 01:55.400
Quindi il compilatore semplicemente metterà da parte 12 posizioni di memoria fondamentalmente imposterà tre diverse matrici

01:56.000 --> 02:06.200
le righe ognuna delle quali ha quattro elementi le colonne ogni riga ha il suo indirizzo iniziale che il

02:06.200 --> 02:15.320
programma recupera e quindi aggiunge l'indice per compensare l'originale indirizzo di memoria per accedere al numero nella

02:15.410 --> 02:17.590
memoria della colonna.

02:17.630 --> 02:21.240
Speriamo che abbia senso.

02:21.710 --> 02:26.660
Ora le matrici sono incredibilmente utili ma potresti chiederti dove mai le useresti.

02:26.660 --> 02:30.890
Bene, guardiamo al futuro per semplificare un argomento davvero complesso.

02:30.890 --> 02:34.340
Copriremo in corso cinque robot autonomi.

02:34.340 --> 02:41.300
Qui è dove cerchiamo di dare ai nostri robot capacità decisionali per

02:41.540 --> 02:53.240
cose come la navigazione d'altura o l'esplorazione delle caverne ecc. Una volta che tali metodi di navigazione sono chiamati localizzazione e mappatura simultanea di Slam.

02:53.630 --> 03:00.230
Usiamo una versione molto semplice di slam e archiviamo i dati in un array in modo da poter capire come

03:00.290 --> 03:02.540
funziona un array in modo pratico.

03:02.570 --> 03:08.510
Supponiamo di avere il tuo robot mobile con gli occhi finti con un sensore a ultrasuoni montato su un motore

03:08.510 --> 03:12.820
servale in modo che possano scansionare completamente 180 gradi da sinistra a destra.

03:13.040 --> 03:20.060
Misurare la distanza da muri e ostacoli e costruire una mappa mentre va così da dove inizia.

03:20.060 --> 03:29.360
Indicheremo tale posizione come zero sull'asse xe zero sull'asse y e la nostra mappa è una griglia di vita

03:29.360 --> 03:31.310
reale in centimetri.

03:31.310 --> 03:38.510
Ora ho l'intera immagine qui sul suo lato in modo da poter vedere di più su schermi ampi, quindi

03:38.510 --> 03:46.310
x negativo sta salendo X positivo sta scendendo e y positivo sta andando dritto dal robot che è a destra

03:46.310 --> 03:47.800
in questa immagine.

03:49.540 --> 03:56.530
Il robot costruirà quella che chiamiamo nuvola di punti misurando le distanze dagli ostacoli circostanti.

03:56.530 --> 04:00.840
Puoi vedere la stanza in cui il robot è nel suo contorno è in grigio.

04:00.920 --> 04:04.480
Ora il robot non sa nulla del suo ambiente.

04:04.480 --> 04:12.250
È appena stato lasciato cadere in un punto casuale e ora naviga simultaneamente nella stanza e la mappa

04:12.340 --> 04:18.790
in modo da scansionare la stanza triangolando i punti intorno ad essa dove ottiene

04:18.790 --> 04:21.100
un riflesso dal sensore ultrasonico.

04:21.100 --> 04:28.630
Ognuna di queste coordinate è memorizzata nel nostro array di mappe principali come semplici numeri di X

04:28.990 --> 04:34.540
e Y centimetri rispetto al nostro punto iniziale iniziale di 0 0.

04:34.590 --> 04:43.080
Ora, quando il robot avanza di 20 cm, può ora eseguire alcune misurazioni e aggiungere alcuni punti alla nuvola esattamente come

04:43.080 --> 04:49.710
ha fatto prima che il robot si muovesse dritto e misurasse il suo movimento in modo

04:49.710 --> 04:52.120
da sapere dove si trova.

04:52.230 --> 05:02.150
Sa che è ancora a 0 centimetri sull'asse x ma ora più 20 centimetri sull'asse y.

05:02.490 --> 05:09.270
Quindi possiamo triangolare nuovamente tutti questi punti rispetto alla sua posizione attuale e aggiungere un intero mucchio

05:09.270 --> 05:13.320
di nuovi punti alla mappa che colpisce i negozi nell'array.

05:13.320 --> 05:20.550
Quindi costruisce questo array man mano che procede evitando gli ostacoli e mappando dove si trovano tutti gli ostacoli

05:22.060 --> 05:26.570
mentre tenta di tornare a casa a 0 0 sulla mappa.

05:26.710 --> 05:32.050
Può cercare tutti questi punti misurandoli tutti attorno e facendo riferimento incrociato ai punti

05:32.050 --> 05:33.040
memorizzati nell'array.

05:33.190 --> 05:38.830
Può sia localizzare che verificare la sua posizione corrente sulla mappa e calcolare le mosse

05:39.100 --> 05:41.650
necessarie per tornare alla posizione iniziale.

05:41.650 --> 05:48.810
Ricorda che i microprocessori trattano solo numeri, quindi la mappa è semplicemente un array multidimensionale.

05:48.850 --> 05:55.930
Entrambi possiamo scrivere tutti quei numeri e leggerli semplicemente La navigazione degli slave di ricerca è più complessa di così,

05:55.930 --> 06:01.480
ma questo semplifica tutto e si spera di vedere un uso immediato per gli array.
