(Carte di controllo)
(Dedica all'Anno Internazionale della Tavola Periodica degli Elementi Chimici)
(Ultimi aggiornamenti fatti l'8 aprile 2019. Elenco degli aggiornamenti subito sotto il tag)
(, )
Ricordo che abbiamo studiato l'anatra. Sono state subito tre lezioni: geografia, scienze naturali e russo. Nella lezione di scienze naturali l'anatra veniva studiata come anatra, con quali ali e quali zampe ha, come nuota e così via. Nella lezione di geografia la stessa anatra veniva studiata come abitante della Terra: bisognava mostrare sulla mappa dove vive e dove non c'è. In russo, Serafima Petrovna ci insegnava a scrivere 'u-t-k-a' e leggeva qualcosa sulle anatre da Brehm. Per sua informazione, ci comunicava che in tedesco l'anatra si dice così, e in francese così. Sembra che allora fosse chiamato 'metodo complesso'. In generale, tutto si faceva 'per caso'.
Veniamin Kaverin, Due capitani
Nella citazione riportata, Veniamin Kaverin ha mostrato magistralmente i difetti del metodo complesso di insegnamento, tuttavia in alcuni (forse piuttosto rari) casi gli elementi di questo metodo possono essere giustificati. Uno di questi casi è la Tavola Periodica di D.I. Mendeleev nelle lezioni di informatica scolastica. L'obiettivo dell'automazione programmata delle azioni standard con la tavola di Mendeleev è chiaro per gli studenti che hanno appena iniziato a studiare chimica e si suddivide in molte tipiche esercitazioni chimiche. Allo stesso tempo, nell'ambito dell'informatica, questo compito consente di dimostrare in modo semplice il metodo delle carte di controllo, che può essere relegato alla programmazione grafica, intesa in senso ampio come programmazione tramite elementi grafici.
(Aggiunte effettuate l'8 aprile 2019:
Iniziamo con il compito di base. Nel caso più semplice, sullo schermo in una finestra-forma deve apparire la Tavola Periodica, dove in ogni cella ci sarà la designazione chimica dell'elemento: H — idrogeno, He — elio, ecc. Se il cursore del mouse indica una cella, nel campo speciale sulla nostra forma appare la designazione dell'elemento e il suo numero. Se l'utente clicca con il pulsante sinistro del mouse, nell'altro campo della forma verranno indicati la designazione e il numero di questo elemento selezionato.
Il compito può essere risolto in qualsiasi linguaggio di programmazione universale. Utilizzeremo il vecchio e semplice Delphi-7, comprensibile quasi a tutti. Ma prima di programmare nel linguaggio di programmazione, disegneremo due immagini, ad esempio, in Photoshop. Innanzitutto, disegneremo la Tavola Periodica nella forma in cui vogliamo vederla nel programma. Salveremo il risultato in un file grafico table01.bmp.
Per il secondo disegno utilizzeremo il primo. Riempiremo progressivamente le celle della tabella ripulite da qualsiasi grafica con colori unici nel modello di colore RGB. R e G saranno sempre 0, mentre B=1 per l'idrogeno, 2 per l'elio e così via. Questo disegno sarà la nostra mappa di controllo, che salveremo in un file con il nome table2.bmp.
La prima fase della programmazione grafica in Photoshop è completata. Passiamo alla programmazione grafica GUI nell'IDE Delphi-7. Per questo apriamo un nuovo progetto, nel quale posizioniamo un pulsante per aprire il dialogo (tableDlg), nel quale si svolgerà il lavoro con la tabella. Poi lavoriamo con il modulo tableDlg.
Posizioniamo nel modulo un componente di classe TImage. Otteniamo Image1. È da notare che, in generale, per progetti di grandi dimensioni, i nomi generati automaticamente del tipo ImageN, dove N possono arrivare a essere decine e oltre — non è il miglior stile di programmazione, e sarebbe meglio dare nomi più significativi. Ma nel nostro piccolo progetto, dove N non supererà 2, possiamo lasciare come è stato generato.
Nel campo Image1.Picture carichiamo il file table01.bmp. Creiamo Image2 e lì carichiamo la nostra mappa di controllo table2.bmp. In questo modo, il file sarà piccolo e invisibile per l'utente, come mostrato nell'angolo in basso a sinistra del modulo. Aggiungiamo ulteriori elementi di controllo, il cui scopo è ovvio. La seconda fase della programmazione grafica GUI nell'IDE Delphi-7 è completata.
Passiamo alla terza fase — scrittura del codice nell'IDE Delphi-7. Il modulo consiste in soli cinque gestori di eventi: creazione del modulo (FormCreate), movimento del cursore su Image1 (Image1MouseMove), clic sinistro sulla cella (Image1Click) e uscita dal dialogo tramite i pulsanti OK (OKBtnClick) o Annulla (CancelBtnClick). I titoli di questi gestori sono generati in modo standard tramite l'IDE.
Codice sorgente del modulo:
unit tableUnit;
// Tabella periodica degli elementi chimici di D.I. Mendeleev
//
// third112
// https://habr.com/ru/users/third112/
//
// Indice
// 1) creazione del modulo
// 2) lavoro con la tabella: indicazione e selezione
// 3) uscita dal dialogo
interface
uses Windows, SysUtils, Classes, Graphics, Forms, Controls, StdCtrls,
Buttons, ExtCtrls;
const
size = 104; // numero di elementi
type
TtableDlg = class(TForm)
OKBtn: TButton;
CancelBtn: TButton;
Bevel1: TBevel;
Image1: TImage; // tabella degli elementi chimici
Label1: TLabel;
Image2: TImage; // mappa di controllo
Label2: TLabel;
Edit1: TEdit;
procedure FormCreate(Sender: TObject); // creazione del modulo
procedure Image1MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer); // indicazione della cella
procedure Image1Click(Sender: TObject); // selezione della cella
procedure OKBtnClick(Sender: TObject); // OK
procedure CancelBtnClick(Sender: TObject); // Annulla
private
{ Dichiarazioni private }
TableSymbols : array [1..size] of string [2]; // array delle designazioni degli elementi
public
{ Dichiarazioni pubbliche }
selectedElement : string; // elemento selezionato
currNo : integer; // numero corrente dell'elemento
end;
var
tableDlg: TtableDlg;
implementation
{$R *.dfm}
const
PeriodicTableStr1=
'HHeLiBeBCNOFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLa';
PeriodicTableStr2='CePrNdPmSmEuGdTbDyHoErTmYbLu';
PeriodicTableStr3='HfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAc';
PeriodicTableStr4='ThPaUNpPuAmCmBkCfEsFmMdNoLrKu ';
// creazione del modulo ==================================================
procedure TtableDlg.FormCreate(Sender: TObject);
// creazione del modulo
var
s : string;
i,j : integer;
begin
currNo := 0;
// inizializzazione dell'array delle designazioni degli elementi:
s := PeriodicTableStr1+ PeriodicTableStr2+PeriodicTableStr3+PeriodicTableStr4;
j := 1;
for i :=1 to size do
begin
TableSymbols [i] := s[j];
inc (j);
if s [j] in ['a'..'z'] then
begin
TableSymbols [i] := TableSymbols [i]+ s [j];
inc (j);
end; // if s [j] in
end; // for i :=1
end; // FormCreate ____________________________________________________
// lavoro con la tabella: indicazione e selezione =========================================
procedure TtableDlg.Image1MouseMove(Sender: TObject; Shift: TShiftState;
X, Y: Integer);
// indicazione della cella
var
sl : integer;
begin
sl := GetBValue(Image2.Canvas.Pixels [x,y]);
if sl in [1..size] then
begin
Label1.Caption := intToStr (sl)+ ' '+TableSymbols [sl];
currNo := sl;
end
else
Label1.Caption := 'Seleziona l'elemento:';
end; // Image1MouseMove ____________________________________________________
procedure TtableDlg.Image1Click(Sender: TObject);
begin
if currNo 0 then
begin
selectedElement := TableSymbols [currNo];
Label2.Caption := intToStr (currNo)+ ' '+selectedElement+ ' selezionato';
Edit1.Text := selectedElement;
end;
end; // Image1Click ____________________________________________________
// uscita dal dialogo ==================================================
procedure TtableDlg.OKBtnClick(Sender: TObject);
begin
selectedElement := Edit1.Text;
hide;
end; // OKBtnClick ____________________________________________________
procedure TtableDlg.CancelBtnClick(Sender: TObject);
begin
hide;
end; // CancelBtnClick ____________________________________________________
end.Nella nostra versione abbiamo utilizzato una tabella di dimensione 104 elementi (costante size). Ovviamente, questa dimensione può essere aumentata. Le designazioni degli elementi (simboli chimici) sono scritte in un array TableSymbols. Tuttavia, per motivi di compattezza del codice sorgente, sembra sensato scrivere la sequenza di queste designazioni come costanti di stringa PeriodicTableStr1,…, PeriodicTableStr4, in modo che, quando si verifica l'evento di creazione della forma, il programma possa distribuire automaticamente queste designazioni tra gli elementi dell'array. Ogni designazione di elemento è composta da una o due lettere latine, con la prima lettera maiuscola e la seconda (se presente) minuscola. Questa regola semplice viene implementata al momento del caricamento dell'array. In questo modo, la sequenza di designazioni può essere scritta in modo compatto senza spazi. La suddivisione della sequenza in quattro parti (costanti PeriodicTableStr1,…, PeriodicTableStr4) è dovuta a considerazioni di comodità di lettura del codice sorgente, poiché una stringa troppo lunga potrebbe non adattarsi interamente sullo schermo.
Quando il cursore del mouse si muove su Image1 l'handler Image1MouseMove di questo evento determina il valore del componente blu del colore del pixel della mappa di controllo Image2 per le coordinate correnti del cursore. In base alla costruzione Image2 questo valore è uguale al numero dell'elemento, se il cursore è all'interno della cella; zero se è sul confine e 255 in altri casi. Le altre azioni eseguite dal programma sono triviali e non richiedono spiegazioni.
Oltre ai riferimenti stilistici di programmazione sopra citati, vale la pena notare lo stile dei commenti. A rigor di termini, il codice considerato è così piccolo e semplice che i commenti non sembrano molto necessari. Tuttavia, sono stati aggiunti anche per motivi metodologici: un codice breve permette di rendere più evidenti alcune conclusioni generali. Nel codice presentato è dichiarata una classe (TtableDlg). I metodi di questa classe possono essere scambiati senza che ciò influisca sul funzionamento del programma, ma potrebbe avere ripercussioni sulla leggibilità. Ad esempio, immaginiamo la sequenza:
OKBtnClick, Image1MouseMove, FormCreate, Image1Click, CancelBtnClick.
Potrebbe non essere molto evidente, ma leggere e comprendere diventerà leggermente più complicato. Se i metodi non sono cinque, ma decine, e nella sezione implementazione hanno un ordine di precedenza completamente diverso rispetto alle descrizioni delle classi, quindi il caos aumenterà solo. Pertanto, sebbene sia difficile e forse addirittura impossibile dimostrarlo rigorosamente, si può sperare che l'introduzione di un ulteriore ordine migliori la leggibilità del codice. Questo ulteriore ordine è facilitato dalla raggruppamento logico di più metodi che svolgono compiti simili. A ciascun gruppo si dovrebbe dare un titolo, ad esempio:
// работа с таблицей: указание и выбор
Questi titoli dovrebbero essere copiati all'inizio del modulo e formattati come un sommario. Nei moduli particolarmente lunghi, tali sommari offrono ulteriori possibilità di navigazione. Analogamente, nel lungo corpo di un metodo, procedura o funzione, si dovrebbe innanzitutto segnare la fine di questo corpo:
fine; // FormCreatee, in secondo luogo, nei costrutti ramificati con parentesi programmatiche begin – end, segnare l'operatore a cui si riferisce la parentesi di chiusura:
fine; // se s [j] in
fine; // per i :=1
fine; // FormCreate
Per evidenziare i titoli dei gruppi e le conclusioni dei corpi dei metodi, si possono aggiungere righe che superano la lunghezza della maggior parte degli operatori e consistono, ad esempio, nei simboli «=» e «_» rispettivamente.
Ancora una volta, va sottolineato: abbiamo un esempio troppo semplice. E quando il codice di un metodo non sta su un solo schermo, può essere complesso districarsi tra sei end successivi per apportare modifiche al codice. In alcuni vecchi compilatori, ad esempio, Pascal 8000 per OS IBM 360/370, nel listing a sinistra veniva stampata una colonna di servizio come
B5
…
E5
Questo significava che la parentesi programmativa di chiusura sulla riga E5 corrisponde alla parentesi di apertura sulla riga B5.
Certo, lo stile di programmazione è una questione molto ambigua, quindi le idee espresse qui dovrebbero essere considerate al massimo come spunti di riflessione. Due programmatori abbastanza esperti, che nel corso degli anni hanno sviluppato e reso familiari stili diversi, possono trovare molto difficile accordarsi. Al contrario, uno studente che sta apprendendo a programmare, e che non ha ancora avuto il tempo di sviluppare il proprio stile, si trova in una situazione diversa. Ritengo che in questo caso l'insegnante debba almeno trasmettere ai propri studenti un concetto semplice, ma non ovvio per loro: il successo di un programma dipende in gran parte dallo stile con cui è scritto il suo codice sorgente. L'allievo potrebbe non seguire lo stile raccomandato, ma almeno dovrebbe riflettere sulla necessità di azioni "superflue" per migliorare la presentazione del codice sorgente.
Tornando al nostro compito di base riguardo alla Tavola Periodica: l'ulteriore sviluppo può seguire direzioni diverse. Una direzione è informativa: quando si posiziona il cursore del mouse su una cella della tabella, appare una finestra informativa contenente ulteriori dettagli sull'elemento specificato. Ulteriore sviluppo implica filtri. Ad esempio, a seconda delle impostazioni nella finestra informativa, possono apparire solo: informazioni fisico-chimiche fondamentali, dettagli sulla storia della scoperta, informazioni sulla diffusione in natura, una lista dei principali composti (a cui appartiene l'elemento in questione), proprietà fisiologiche, nome in lingua straniera, ecc. Ricordando l'"anatra" di Kaverin, che apre questo articolo, si può dire che con tale sviluppo del programma otterremo un completo complesso educativo sulle scienze naturali: oltre all'informatica, fisica e chimica – biologia, geografia economica, storia della scienza e persino lingue straniere.
Ma una banca dati locale non è un limite. Il programma si collega naturalmente a Internet. Se si seleziona un elemento, scatta un link, e nella finestra del browser web si apre un articolo di Wikipedia su quell'elemento. Wikipedia, come noto, non è una fonte autoritativa. È possibile fornire riferimenti a fonti autorevoli, come un'enciclopedia chimica, il BSE, riviste referative, richiedere query nei motori di ricerca su quell'elemento, ecc. In questo modo, gli studenti potranno svolgere compiti semplici ma significativi sui temi dei DBMS e di Internet.
Oltre alle richieste su un singolo elemento, è possibile realizzare una funzionalità che evidenzi, ad esempio, con colori diversi le celle in una tabella che corrispondono a determinati criteri. Ad esempio, metalli e non metalli. O celle che il locale stabilimento chimico immette nei corpi idrici.
È anche possibile implementare funzioni di un'agenda organizzativa. Ad esempio, evidenziare nella tabella gli elementi che fanno parte dell'esame. Successivamente, evidenziare gli elementi studiati/ripetuti dallo studente durante la preparazione all'esame.
Ecco, ad esempio, uno dei compiti tipici della chimica scolastica:
Data una massa di 10 g di gesso. Quanta acido cloridrico è necessario per sciogliere completamente questo gesso?
Per risolvere questo problema, bisogna scrivere la reazione chimica e impostare i coefficienti, calcolare i pesi molecolari del carbonato di calcio e dell'acido cloridrico, e poi impostare e risolvere una proporzione. Il calcolatore basato sul nostro programma di base sarà in grado di calcolare e risolvere. Tuttavia, sarà necessario anche tenere conto che l'acido deve essere preso con un'adeguata eccedenza e a una concentrazione ragionevole, ma questo è già chimica, non informatica.
Aggiunta 1: come funziona il calcolatore chimicoEsaminiamo il funzionamento del calcolatore utilizzando l'esempio del problema del gesso e della "soluzione acida" sopra menzionato. Iniziamo con la reazione:
CaCO3 + 2HCl = CaCl2 + H2O
Da qui vediamo che avremo bisogno dei pesi atomici dei seguenti elementi: calcio (Ca), carbonio (C), ossigeno (O), idrogeno (H) e cloro (Cl). Nel caso più semplice, possiamo scrivere questi pesi in un array unidimensionale definito come
AtomicMass : array [1..size] of real;dove l'indice dell'array corrisponde al numero dell'elemento. Inoltre, in uno spazio libero del modulo tableDlg posizioniamo due campi. Nel primo campo è inizialmente scritto: "Il primo reagente è dato", nel secondo - "Trovare il secondo reagente x". Denotiamo i campi reagent1, reagent2 rispettivamente. Altre aggiunte al programma saranno chiare dal seguente esempio di funzionamento del calcolatore.
Digitando sulla tastiera del computer: 10 g. La scritta nel campo reagent1 cambia: "Il primo reagente è dato 10 g". Ora introduciamo la formula di questo reagente, e il calcolatore calcolerà e mostrerà il suo peso molecolare man mano che viene inserito.
Clicchiamo con il pulsante sinistro del mouse su una cella della tabella con il simbolo Ca. La scritta nel campo reagent1 cambia: "Il primo reagente Ca 40.078 è dato 10 g".
Clicchiamo con il pulsante sinistro del mouse su una cella della tabella con il simbolo C. La scritta nel campo reagent1 cambia: "Il primo reagente CaC 52.089 è dato 10 g". Cioè, il calcolatore ha sommato i pesi atomici del calcio e del carbonio.
Clicchiamo con il pulsante sinistro del mouse sulla cella della tabella con il simbolo O. La scritta nel campo reagent1 cambia: “Primo reagente CaCO 68.088 dato 10 g”. Il calcolatore ha aggiunto al totale il peso atomico dell'ossigeno.
Clicchiamo con il pulsante sinistro del mouse sulla cella della tabella con il simbolo O. La scritta nel campo reagent1 cambia: “Primo reagente CaCO2 84.087 dato 10 g”. Il calcolatore ha aggiunto nuovamente al totale il peso atomico dell'ossigeno.
Clicchiamo con il pulsante sinistro del mouse sulla cella della tabella con il simbolo O. La scritta nel campo reagent1 cambia: “Primo reagente CaCO3 100.086 dato 10 g”. Il calcolatore ha aggiunto ancora una volta al totale il peso atomico dell'ossigeno.
Clicchiamo Invio sulla tastiera del computer. L'inserimento del primo reagente è completato e si passa al campo reagent2. Notiamo che in questo esempio presentiamo una versione minima. Se desiderato, è facile organizzare moltiplicatori per atomi dello stesso tipo, in modo da non dover cliccare sette volte sulla cella dell'ossigeno quando si inserisce la formula del cromato (K2Cr2O7).
Clicchiamo con il pulsante sinistro del mouse sulla cella della tabella con il simbolo H. La scritta nel campo reagent2 cambia: “Secondo reagente H 1.008 trova x”.
Clicchiamo con il pulsante sinistro del mouse sulla cella della tabella con il simbolo Cl. La scritta nel campo reagent2 cambia: “Secondo reagente HCl 36.458 trova x”. Il calcolatore ha sommato i pesi atomici dell'idrogeno e del cloro. Nell'equazione di reazione sopra, davanti all'acido cloridrico c'è un coefficiente 2. Quindi clicchiamo con il pulsante sinistro del mouse sul campo reagent2. Il peso molecolare raddoppia (con una doppia pressione triplica, ecc.). La scritta nel campo reagent2 cambia: “Secondo reagente 2HCl 72.916 trova x”.
Clicchiamo Invio sulla tastiera del computer. L'inserimento del secondo reagente è completato e il calcolatore trova x dalla proporzione
Che si volevano trovare.
Nota 1. Il significato della proporzione ottenuta: per sciogliere 100.086 gesso sono necessari 72.916 Da di acido, e per sciogliere 10 g di gesso serve x di acido.
Nota 2. Raccolte di problemi simili:
Khomenko I. G., Raccolta di compiti e esercizi di chimica 2009 (8-11 classe).
Khomenko G. P., Khomenko I. G., Raccolta di problemi di chimica per l'ammissione all'università, 2019.
Nota 3. Per semplificare il compito, è possibile nella versione iniziale semplificare l'inserimento della formula e semplicemente aggiungere il simbolo dell'elemento alla fine della stringa della formula. Quindi la formula del carbonato di calcio avrà la forma:
CaCOOO
Ma tale registrazione difficilmente piacerà all'insegnante di chimica. È facile fare la registrazione corretta: basta aggiungere un array:
formula : array [1..size] of integer;dove l'indice è il numero dell'elemento chimico e il valore corrispondente a questo indice è il numero di atomi (inizialmente tutti gli elementi dell'array vengono azzerati). È importante considerare l'ordine di scrittura degli atomi nella formula, come previsto in chimica. Ad esempio, O3CaC non sarà di gradimento a molti. Trasferiamo la responsabilità all'utente. Creiamo un array:
formulaOrder : array [1..size] of integer; // si può abbreviaredove scriviamo il numero dell'elemento chimico in base all'indice della sua apparizione nella formula. Aggiunta dell'atomo currNo nella formula:
if formula [currNo]=0 then // questo atomo è apparso per la prima volta
begin
orderIndex := orderIndex+1; // all'inizio dell'inserimento della formula orderIndex=0
formulaOrder [orderIndex] := currNo;
end;
formula [currNo]:=formula [currNo]+1;Registrazione della formula in una stringa:
s := ''; // stringa vuota per la formula
for i:=1 to orderIndex do // per tutti i simboli chimici nella formula
begin
s:=s+TableSymbols [ formulaOrder[i]]; // aggiungiamo il simbolo chimico
if formula [formulaOrder[i]]<1 then // aggiungiamo il numero di atomi
s:=s+ intToStr(formula [formulaOrder[i]]);
end;
Nota 4. Ha senso garantire la possibilità di un'immissione alternativa della formula del reagente tramite la tastiera. In questo caso sarà necessario implementare un semplice parser sintattico.
Vale la pena notare che:
Oggi esistono diverse centinaia di varianti della tavola, e gli scienziati propongono continuamente nuove opzioni. ()
Gli studenti possono dimostrare ingegno anche in questa direzione, implementando una delle varianti già proposte o provando a creare la propria originale. Potrebbe sembrare che questa sia la direzione meno utile per le lezioni di informatica. Tuttavia, nella forma della Tavola Periodica realizzata in questo articolo, alcuni studenti potrebbero non riconoscere i vantaggi specifici delle schede di controllo rispetto a una soluzione alternativa tramite pulsanti standard TButton. La forma a spirale della tavola (dove le celle hanno forme diverse) dimostrerà più chiaramente i vantaggi della soluzione proposta qui.
(, )
Aggiungiamo anche che di alcuni programmi informatici attualmente esistenti per la Tavola di Mendeleev si è parlato in un recente articolo pubblicato su Habr .
Supplemento 2: esempi di compiti per filtriCon l'aiuto dei filtri è possibile risolvere, ad esempio, i seguenti compiti:
1) Selezionare nella tavola tutti gli elementi noti nel medioevo.
2) Selezionare tutti gli elementi noti al momento della scoperta della legge periodica.
3) Selezionare sette elementi che gli alchimisti consideravano metalli.
4) Selezionare tutti gli elementi che si trovano in stato gassoso a condizioni normali (c.n.).
5) Selezionare tutti gli elementi che si trovano in stato liquido a c.n.
6) Selezionare tutti gli elementi che si trovano in stato solido a c.n.
7) Selezionare tutti gli elementi che possono rimanere a lungo all'aria senza variazioni significative a c.n.
8) Selezionare tutti i metalli che si dissolvono in acido cloridrico.
9) Selezionare tutti i metalli che si dissolvono in acido solforico a c.n.
10) Selezionare tutti i metalli che si dissolvono in acido solforico riscaldando.
11) Selezionare tutti i metalli che si dissolvono in acido nitrico.
12) Selezionare tutti i metalli che reagiscono vigorosamente con l'acqua a c.n.
13) Selezionare tutti i metalli.
14) Selezionare elementi ampiamente diffusi in natura.
15) Selezionare elementi che si trovano in natura in stato libero.
16) Selezionare elementi che svolgono un ruolo fondamentale nell'organismo umano e animale.
17) Selezionare elementi che vengono ampiamente utilizzati nella vita quotidiana (in forma libera o in composti).
18) Selezionare elementi con cui lavorare è più pericoloso e richiede misure e attrezzature di protezione speciali.
19) Selezionare elementi che, in forma libera o come composti, rappresentano la maggiore minaccia per l'ecologia.
20) Selezionare metalli preziosi.
21) Selezionare elementi che costano più dei metalli preziosi.
Note
1) Ha senso garantire il funzionamento di più filtri. Ad esempio, se si attiva il filtro per la risoluzione del problema 1 (tutti gli elementi conosciuti nel medioevo) e 20 (metalli preziosi), verranno evidenziate (ad esempio, con un colore) le celle con i metalli preziosi conosciuti nel medioevo (ad esempio, il palladio, scoperto nel 1803, non sarà evidenziato).
2) Ha senso garantire il funzionamento di più filtri in modo tale che ciascun filtro evidenzi le celle con il proprio colore, senza rimuovere completamente l'evidenziazione di un altro filtro (parte della cella di un colore, parte di un altro). In tal modo, nel caso dell'esempio precedente, saranno visibili gli elementi di intersezione tra i vettori aperti nel Medioevo e i metalli preziosi, così come gli elementi che appartengono solo al primo e solo al secondo insieme. Cioè, i metalli preziosi sconosciuti nel Medioevo e gli elementi noti nel Medioevo, ma non considerati metalli preziosi.
3) Ha senso garantire la possibilità di svolgere altre operazioni con i risultati ottenuti dopo aver applicato il filtro. Ad esempio, evidenziando gli elementi noti nel Medioevo, l'utente clicca con il tasto sinistro del mouse su un elemento evidenziato e accede all'articolo di Wikipedia su quell'elemento.
4) Ha senso garantire all'utente la possibilità di rimuovere l'evidenziazione cliccando con il tasto sinistro del mouse sulla cella evidenziata della tabella. Ad esempio, per rimuovere gli elementi già visualizzati.
5) Ha senso garantire il salvataggio dell'elenco delle celle evidenziate in un file e il caricamento di tale file con l'evidenziazione automatica delle celle. Questo darà all'utente la possibilità di prendersi una pausa dal lavoro.
Abbiamo utilizzato una mappa di controllo statica predefinita, tuttavia ci sono molte importanti attività in cui possono essere utilizzate mappe di controllo dinamiche, che cambiano durante l'esecuzione del programma. Un esempio potrebbe essere un editor di grafi, in cui l'utente indica con il mouse nelle posizioni delle vette e disegna i bordi tra di esse. Per rimuovere un vertice o un bordo, l'utente deve puntare su di essi. Ma se puntare su un vertice contrassegnato da un cerchio è abbastanza semplice, farlo su un bordo disegnato con una linea sottile sarà più difficile. Qui aiuta la mappa di controllo, in cui le vette e i bordi occupano aree più ampie rispetto a quelle visibili nel disegno.
Con il metodo di apprendimento complesso trattato si lega una questione secondaria interessante: può questo metodo essere utile nell'addestramento dell'IA?
Fonte: habr.com
