Formattazione

© Allan Hayes, 1998. Versione italiana di Gianluca Gorni, 2001

Vediamo qui cosa si come si possono formattare formule e tabelle nei documenti di Mathematica solo coi menu, senza particolare programmazione.

Azzerare le opzioni

Talvolta quando si formatta del testo aggiungendo opzioni e non ci si raccapezza più,  la cosa migliore è di ricominciare da zero.
Questo si può fare selezionando da celle di testo (comprese quelle di titoli e sezioni) senza dover riscrivere nulla usando Format> Remove Options ...

Formattazione dei calcoli

Convertire formati

Scrivete

Integrate[(x y)/(x^3 + y^3), x](*integrare rispetto a x*)

Inverse[{{1,2},{3,4}}]

Gli input sono nella forma lineare  InputForm: usano nomi di comandi di Mathematica.
Gli output sono in StandardForm: assomiglia alla forma tradizionale, ma senza ambiguità.
Per  convertirele celle di input e output qui sopra in TraditionalForm:
   - selezionare le due celle;
   - scegliere il menu Cell>Convert To>TraditionalForm o battere ⌘|⇧[T]
ottenendo (notare le grafe a margine seghettate)

∫((x y)/((x^3)+(y^3)))\[DifferentialD]x

(((({{1, 2}, {3, 4}})))^(-1))

- Analogamente, per convertire tutto in StandardForm usare Cell>Convert To>StandardForm o  ⌘|⇧[N]:

∫((x y)/((x^3)+(y^3)))\[DifferentialD]x

Inverse[{{1,2},{3,4}}]

-  Per convertire in  InputForm (con * per la moltiplicazione) usare Cell>Convert To>InputForm o ⌘|⇧[I]

Integrate[(x*y)/(x^3 + y^3), x]

Inverse[{{1, 2}, {3, 4}}]

Le varie forme sono utili in diverse circostanze.
• InputForm è l'ideale per programmare, e una volta imparati i nomi delle funzioni di Mathematica e le sue strutture regolari, viene facile da scrivere
• TraditionalForm è bella da vedere per le formule matematiche, ma è macchinosa da scrivere i primi tempi; inoltre ci sono ambiguità che Mathematica non sempre risolve. 
• StandardForm assomiglia molto alla forma tradizionale, è chiara sullo schermo e non è ambigua.

StandardForm e InputFrom sono computazionalmente equivalenti: danno lo stesso output.
Sebbene TraditionalForm sia talvolta ambigua, di solito è computazionalmente equivalente alle altre.
- Confrontate le versioni del primo input in  InputForm, StandardForm e TraditionalForm:

Integrate[(x y)/(x^3 + y^3), x]

∫((x y)/((x^3)+(y^3)))\[DifferentialD]x

∫((x y)/((x^3)+(y^3)))\[DifferentialD]x

- valutarle una alla volta (ignorare il messaggio di avvertimento della  TraditionalForm).
Dovrebbe venire lo stesso output.

Formattare parti di una formula

Una parte di una formula dentro una cella si può convertire selezionando l'espressione e usando lo stesso menu usato sopra per l'intera cella.
Per esempio, convertire l'integrando seguente a  TraditionalForm

Integrate[(x y)/(x^3 + y^3), x]

ottenendo

Integrate[((x y)/((x^3)+(y^3))), x]

Formati di output da programmazione: trabocchetti

La formattazione fin qua è stata fatta da menu o con abbreviazioni da tastiera.
Possiamo anche programmare l'input in modo che l'output venga direttamente nel formato voluto. Per esempio

TraditionalForm[Integrate[1/(x^3 + 1), x]]

L'etichetta di cellal, Out[n]//TraditionalForm, ci avverte che quella che vediamo è la  TraditionalForm di Out[n],non la forma di default delle celle di output, che è StandardForm.

Ci sono molte altre forme di output che si possono imporre in questo modo. Parleremo di cosa succede con MatrixForm,che si usa spesso e che lascia perplessi molte volte, ma cose simili succedono anche per le altre forme di output. Una lista completa delle forme di output è

$OutputForms

Consideriamo

a = {{2},{3}};

MatrixForm[a]

Quando mandiamoMatrixForm[a] al nòcciolo, prima diventa MatrixForm[{{2},{3}}], e questo viene spedito al Front End per la visualizzazione (l'etichetta Out[n]//MatrixForm ce lo dice), ma poi la "confezione" MatrixForm[...] viene tolta e il valore di Out[n] è {{2},{3}}. Quindi Out[n] coincide esattamente con a e non è formattato.

%

Ma lo scartocciamento della  MatrixForm succede solo se la testa( più esterna) dell'espressione da visualizzare è MatrixForm.Se MatrixForm compare all'interno dell'espressione, non viene tolta, e si va incontro a sorprese.

3 +MatrixForm[a]

Il motivo è che MatrixForm  attorno ad a viene mantenuta, e impedisce che l'addizione con 3 entri dentro nelle liste (oltre che cambiare la formattazione).

Attenzione: una definizione come la seguente dà degli strani risultati:

f = MatrixForm[a]

L'assegnazione viene fatta prima della visualizzazione dell'output, e MatrixForm rimane al membro di destra:

?f

Così ritroviamo il problema di 3 + MatrixForm[a].

3 + f

Se vogliamo che f sia la semplice struttura {{2},{2}}  ma lo vogliamo vedere in MatrixForm possiamo scrivere

MatrixForm[f= a]

Ora

?f

Formattare l'input

Nelle sezioni precedenti abbiamo prodotto forme tradizionali e standard di espressioni convertendole dalla InputForm. Qui le costruiremo passo dopo passo usando tavolozze e abbreviazioni da tastiera.

Date uno sguardo ai menu
	File>Palettes, 
	Edit>Expression Input, 
	Input>Create Table/Matrix/Palette
Le operazioni che vedremo funzionano sia in celle di testo che in celle di input, eccetto una, che serve solo alle celle di testo. Cominciamo con le celle di input.

Vediamo come produrre gli input seguenti, prima con le tavolozze e poi con comandi da tastiera:

∫(x/(((x^2)+1)^(1/3)))\[DifferentialD]x

(({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}))

I'output sarà in StandardForm (il default per le celle di  Output):si convertirà nelle altre forme come visto sopra.

Con le tavolozze

- Scegliete File>Palettes>BasicInput (compare una tavolozza,  se non è già aperta);

Costruire l'integrale dall'interno verso l'esterno:

-  (■/□) ; 	((◼/□) è il template, □ un segnaposto, ◼ il segnaposto selezionato)	
-  x;
-  ⇥	 	(andare al segnaposto seguente);
- (Sqrt[■])  	(la selezione è rimpiazzata dal template con la selezione al posto di ■ )
- (■^□);
- x, ⇥, 2
- Ctrl|␣ 	(uscire dalla struttura bidimensionale (x^2))
- + 1
- Ctrl[%] 	(far apparire il segnaposto opposto)
- 3
- Ctrl[...] 	(scrivere punti finché non viene selezionata l'espressione intera);
- ∫■d□  	
- x

- provate a costruire lo stesso integrale partendo dall'esterno con  ∫■d□  
Facciamo la matrice:
 
-  (({{□, □}, {□, □}})) 
-  1,  ⇥, 2, 
-  Ctrl[,] (adds a column)
-  3, ⇥, 4, ⇥, 5, ⇥, 6 
-  Ctrl|⏎ (adds a row)
-  7,⇥, 8,⇥ 9

Ci sono molti altri modi di usare la tavolozza per fare queste stesse espressioni.

Con comandi da tastiera

L'integrale:

- Esc int Esc (dà il segno di integrale)
- x
- Ctrl[/] (fa la frazione)
- x
- Ctrl[6] (inserisce un segnaposto all'esponente)
- 2
- Ctrl|␣ (uscire dalla struttura bidimensionale (x^2))
-  + 1
- selezionare (x^2)+1 (usare Ctrl[... ]);
- Ctrl[2] (mette la selezione sotto radice quadrata)
- selezionare (x^2)+1 (usare Ctrl[... ]);
- Ctrl[%] 	(far apparire il segnaposto opposto
- 3
- Ctrl|␣,  Ctrl|␣  (uscire dalla struttura bidimensionale (1/(((x^2)+1)^(1/3))))
- Esc dd Esc (fare il differenziale d , non usare una d ordinaria)
- x

La matrice, in due modi:

(1) un passo alla volta:
- scrivere quanto segue riga dopo riga, da sinistra a destra:

	({{(, 1, Ctrl[,], 2, Ctrl[,], 3, Ctrl[↵],  }, { , 4, ⇥, 5, ⇥, 6, Ctrl[↵],  }, { , 7, ⇥, 8, ⇥, 9,  , )}}) 
	
  - scrivere quanto segue una colonna alla volta, dall'alto in basso:
  	({{(, (1, Ctrl[↵]), (2, ⇥), (3, ⇥),  }, { , (4, Ctrl[↵]), (5, ⇥), (6, ⇥),  }, { , (7, Ctrl[,]), (8, Ctrl[,]), (9,  ), )}})

(2) costruire una griglia con il comando:
- ⌘|⇧[C] o Input>CreateTable/Hyperlink/Matrix/Palette... (inserire i dati per una matrice di 3 righe e 3 colonne, senza righe, cornice o riempitivi)
riempire i segnaposto:
- cliccare sul segnaposto in alto a sinistra e poi
- scrivere 1, ⇥, 2, ⇥, 3, ....  fin quando la griglia non è riempita.

Formule nel testo

Costruiremo la seguente cella di testo incorniciata usando i metodi della sottosezione precedente per le formule.

Mathematica calcola ∫(1/((x^2)+1))dx e l'inversa di  (({{1, 2}, {1, 3}})) molto velocemente.

Fare attenzione ai passi (*) per iniziare e finire una cella inline e le spiegazioni che seguono.

- cliccare fuori da qualsiasi cella (per avere una riga di inserzione celle), 
- scegliere Format/Style/Text (per avere una cella di testo);
- scrivere "Mathematica calculates "  (appare come testo);
- Ctrl[9] (per cominciare una cella inline, con sfondo rosa) 			(*)
- fare ∫(1/((x^2)+1))dx
- Ctrl[0] (per uscire dalla cella inline)						(*)
- scrivere "e l'inversa di "	
- Ctrl[9] (per cominciare una cella inline)                                                       	(*)	
- scrivere "(" , fare ({{1, 2}, {1, 3}})  , scrivere ")"   
- Ctrl[0] (per uscire dalla cella inline)						(*)	
- scrivere " molto velocemente."

Le formule nelle celle di testo devono essere celle inline, e vanno chiuse alla fine della formula. 
• per cominciare una cella inline usare Ctrl[9]
• le celle inline hanno sfondo rosa quando ci si clicca dentro;
• le formule nelle celle inline non sono automaticamente mostrate in forma bidimensionale; per esempio  a^n non diventa automaticamente (a^n).
• per avere le forme bidimensionali mentre si scrive dobbiamo usare o bottoni della tavolozza come  (■^□) oppure comandi da tastiera come  Ctrl[ ^ ]. 
• qualsiasi espressione si può convertire in forma tradizionale bidimensionale (o standard) selezionandola e premento  ⌘|⇧[T] (⌘|⇧[N])  .
• le celle inline si iniziano automaticamente se usiamo un bottone di tavolozza o un comando da tastiera tipo  Ctrl[ ^ ] al di fuori da una cella inline. 
• per uscire da una cella inline usare Ctrl[0].

Cosa fa una cella inline?
• fa seguire la convenzione secondo cui singole lettere in una formula vanno in corsivo;
• aiuta Mathematica a interpretare la formula quando viene valutata.

Per esempio

Nella cella che segue il secondo integrale è in una cella inline, il primo no:

∫sin(x)dx   ∫sin(x)dx

Valutiamo gli integrali in loco, uno alla volta:

(sin*x^2)/2  -cos(x)

Qui ho copiato e incollato il primo integrale in una cella di input e ho valutato. La risposta non è quella "giusta": il sin viene interpretato come una costante moltiplicativa

∫sin(x)\[DifferentialD]x

Se non vi importa di valutare le formule, vi puo bastare che siano belle da vedere, ma se, come me, volete poterle valutare all'occorrenza, dato il rischio che le forme tradizionali non siano interpretate correttamente, è prudente scrivere in forma input o standare, e soltanto dopo tradurre in forma tradizionale.
Qui sotto ci sono tre righe con l'integrale a sinistra prima in InputForm; poi convertito nella seconda riga a StandardForm, e infine in forma tradizionale; infine in ogni riga copio l'integrale di sinistra, lo incollo a destra e lo valuto in loco.
Notare che la valutazione in loco ha conservato la forma (benché talvolta bisogna stare attenti nel selezionare bene l'integrale)

Integrate[Sin[Sqrt[x]], x]        -2*Sqrt[x]*Cos[Sqrt[x]] + 2*Sin[Sqrt[x]]

∫Sin[(Sqrt[x])]dx		-2 (Sqrt[x]) Cos[(Sqrt[x])]+2 Sin[(Sqrt[x])]

∫sin((Sqrt[x]))dx			2 sin((Sqrt[x]))-2 (Sqrt[x]) cos((Sqrt[x]))

Se la formula è l'unico contenuto della cella, possiamo convertire la cella intera invece di selezionare il contenuto e poi convertire.

Spostare il cursore e selezionare parte del testo

- Fare le due celle seguenti (la cella di testo ha una cella inline da a a b...

Cella di testo:  a+□+(∫_□^□)(□/(Sqrt[1 + □]))d□+b  + c + □ +d

Cella di Input: a+\[Placeholder]+ (∫_\[Placeholder]^\[Placeholder])(\[Placeholder]/(Sqrt[1+\[Placeholder]]))\[DifferentialD]\[Placeholder] + b +c + \[Placeholder]+ d

- provare le tecniche seguenti:

({{cliccare, in una cella inline produce uno sfondo rosa}, {⇥, in una cella inline o di input:
            all'inizio di cella: inserisce uno spazio(rappresentato nell'espressione di cella da \t)
            altrimenti:seleziona il segnaposto seguente, se ce n'è, altrimenti non fa nulla
nelle altre celle inserisce un carattere di tabulazione}, {Ctrl[␣], esce dalla struttura bidimensionale immediatamente contenente se c'è, altrimenti
 dalla cella inline}, {Ctrl[0], entra nella cella seguente, se ce n'è (o termina una cella inline)	}, {Ctrl[.], estende la selezione}, {doppio clic , estende la selezione, ma rimanendo nella cella (compresa la cella  inline)}, {freccia, come ci si immagina}})

Vedi anche: Edit > Motion and Edit >Expression Input

Alfabeti e simboli

C'è una raccolta vastissima di alfabeti e simboli. Vedi le tavolozze in File/Palettes.
Le corrispondenti combinazioni da tastiera seguono spesso delle regole facili:

({{Alfabeto, prefisso,                                esempi,  }, {Greek,  ,     \[EscapeKey]g\[EscapeKey] ⟶ γ, \[EscapeKey]G\[EscapeKey] ⟶Γ}, {Script, sc,     \[EscapeKey]scg\[EscapeKey] ⟶ℊ, \[EscapeKey]scG\[EscapeKey] ⟶𝒢}, {Gothic, go,     \[EscapeKey]gog\[EscapeKey] ⟶ 𝔤 , \[EscapeKey]goG\[EscapeKey] ⟶ 𝔊}, {DoubleStruck, ds,     \[EscapeKey]dsg\[EscapeKey] ⟶ 𝕘 , \[EscapeKey]dsG\[EscapeKey] ⟶ 𝔾}})

\[EscapeKey]int\[EscapeKey] ⟶ ∫,       \[EscapeKey]pd\[EscapeKey] ⟶ ∂, 
\[EscapeKey]sum\[EscapeKey] ⟶ ∑ ,     \[EscapeKey]prod\[EscapeKey] ⟶ ∏

(Gli ultimi quattro simboli sono associati a funzioni; per avere semplici lettere greche usare  Esc, S, Esc (=Σ) e Esc, P, Esc (=Π))

Aggiustamenti minuti di spaziatura (kerning)

Nelle celle di testo (Text, Title, Section ....) il comando seguente funziona solo nelle celle inline:

Ctrl|[ freccia] sposta la selezione della minima distanza di schermo nella direzione della freccia.

Comandi da tastiera

Nella tabella seguente useremo le forme maiuscole (quelle che si ottengono tenendo premuto il tasto maiuscole) perché sono più facili da ricordare, ma lo stesso risultato si ha senza usare il tasto maiuscole. Per esempio ^ e 6 sono equivalenti. 
Ctrl[%] genera un segnaposto nella posizione opposta.

Effetti dei comandi da tastiera:
x deve essere una selezione o un'espressione seguita dal punto di inserzione 
x must be  a selection  or  an expession  with the insertion point after  it
sel  deve essere una selezione					

	({{x, Ctrl[^]   , (x^□), Ctrl[%], (Subscript[x, □]^□)}, {x, Ctrl[_]    , (Subscript[x, □]), .. , (Subscript[x, □]^□)}, {x, Ctrl[ & ]  , (Overscript[x, □]), .., (Underoverscript[x, □, □])}, {x, Ctrl[=] , (Underscript[x, □]),  .., (Underoverscript[x, □, □])}, {x, Ctrl[/]   , (x/□),  ..,  senza opposto}, {sel , Ctrl[ 2 ]   , (Sqrt[sel]),  .., (sel^(1/□))}, { , Ctrl[ & ]  , (Overscript[□, □]),  .., (Underoverscript[□, □, □])}, { , Ctrl[=]  , (Underscript[□, □]), .. , (Underoverscript[□, □, □])}, { , Ctrl[/]    , (□/□), .., senza opposto}, { , Ctrl[ 2 ]   , (Sqrt[□]), .., (□^(1/□))}})

Fare una griglia:

Ctrl|⇧[C] -> apre un pannello per produrre tabelle, matrici e tavolozze
	Ctrl[,]    -> nuova colonna (si può usare ovunque)
	Ctrl[↵]   -> nuova riga (si può usare ovunque)

Caratteri avvolgenti

Fare

(({{1, (4/5)}, {(3/7), 2}})}]

Le parentesi tonde ( , )  si espandono per abbracciare l'espressione che contengono: sono caratteri estensibili, o avvolgenti.
Le graffe {,} e le quadre [,] si espandono per default solo di tot al massimo.
L'avvolgenza si controlla con Edit>Expression Input>SpanningCharacters, e più in dettaglio con  Format>Option Inspector>FormattingOptions>Expression Formatting>Spanning Character Options

- selezionare l'espressione (comprese tutte le parentesi), o selezionare la cella a margine
- scegliere Edit > Expression Input >SpanningCharacters > Expand Indefinitely
- selezionare la parentesi tonda sinistra (
- scegliere Edit > Expression Input >SpanningCharacters > Don't Expand

(({{1, (4/5)}, {(3/7), 2}})}]

(({{1, (4/5)}, {(3/7), 2}})}]

Fare le seguenti celle di testo (con una griglia 2×1)

({{(((a+b))^2)=((a^2)+2 b a+(b^2)) }, {(((a+b))^3)=((a^3)+3 b (a^2)+3 (b^2) a+(b^3))}})   }

Usare Format>Option Inspector>FormattingOptions>Expression Formatting>Spanning Character Options per cambiare la dimensione della graffa }.

({{(((a+b))^2)=((a^2)+2 b a+(b^2)) }, {(((a+b))^3)=((a^3)+3 b (a^2)+3 (b^2) a+(b^3))}})   }

L'avvolgimento può essere orizzontale:

a+b

Per avere quanto segue scrivere a+b; selezionarlo; Ctrl[ & ]; scrivere --> (o \[LongRightArrow ])

(Overscript[a + b, ⟶])

Griglie

- usando Input>Create Table/Matrix/Palette ( o ⌘|⇧[C]) costruire la griglia seguente

Una gliglia vuota è una disposizione a scacchiera di segnaposti

({{\[Placeholder], \[Placeholder], \[Placeholder], \[Placeholder]}, {\[Placeholder], \[Placeholder], \[Placeholder], \[Placeholder]}, {\[Placeholder], \[Placeholder], \[Placeholder], \[Placeholder]}})

si può costruire in celle di input e in celle di testo in due modi:
• tutt in una volta, usando Input>Create Table/Matrix/Palette o ⌘|⇧[C] (il pannello ci dà controllo sugli elementi di default, le linee fra righe e fra colonne, cornice e parentesi attorno)).

• un passo alla volta, usando Ctrl[,] (nuova colonna) e Ctrl|⏎ nuova riga)

Le griglie sono molto adattabili: 
- costruire quanto segue usando Ctrl[,],Ctrl|⏎, taglio, copia e incollamento di sottomatrici:

(({{1, 2, c, 3}, {4, 5, c, 6}, {r, r, m, r}, {7, 8, c, 9}})), (({{1, 2, c, 3}, {\[Placeholder], \[Placeholder], c, 6}, {\[Placeholder], \[Placeholder], m, r}, {7, 8, c, 9}})), (({{1, 2, c, 3, \[Placeholder], \[Placeholder], m, r}, {\[Placeholder], \[Placeholder], c, 6, 7, 8, c, 9}}))
			(({{1, 2, c, 3}, {4, 5, c, 6}, {r, r, m,  (({{1, 2, c, 3}, {\[Placeholder], \[Placeholder], c, 6}})({{\[Placeholder], \[Placeholder], m, r}, {7, 8, c, 9}}))}, {7, 8, c, 9}}))

- provare l'effetto di  Ctrl[,],Ctrl|⏎, taglio, copia e incollamento in posti diversi di una griglia

La sezione che segue elenca le regole che governano il comporamento delle griglie.

Produrre e cambiare le griglie

Al di fuori della griglia (per lavorare al''interno vedi la sezione seguente)

1) Palette File>Paletttes>Basic Input

(({{\[Placeholder], \[Placeholder]}, {\[Placeholder], \[Placeholder]}}))

2) Input>Create Table/Matrix/Palette ( o ⌘|⇧[C]);
scegliere il numero di righe e colonne, le linee separatrici, la cornice, le parentesi attorno:

({{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}}) , (({{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}})),  ({{x, 0, 0, 0}, {0, x, 0, 0}, {0, 0, x, 0}}),

3) scegliere (non a cavallo di blocchi di griglie);  ⌘[,] (⌘|↵):

aa,  bb  —( selezionare bb;  ⌘|↵ )⟶     aa,  ({{bb}, {□}})

aa,  bb  —( selezionare bb;  ⌘[,] )⟶     aa,  ({{bb, □}})

4)  cliccare; ⌘[,] (⌘|↵): del materiale M(*) a sinistra del cursore viene selezionato e diventa l'elemento in alto a sinistra di una nuova griglia 1 ×2 (2×1), mentre l'altro posto della griglia contiene un segnaposto vuoto.
(*)M dipende dal tipo di cella in cui si lavora; provando e riprovando si estraggono le regole seguenti:
   • per le celle di input e le celle inline: 
  Cominciare la scansione verso sinistra nello stato s[] 
  La regione di ricerca è la più piccola cella o parte di una struttura bidimensionale contenente il cursore (per esempio il denominatore di una frazione o l'esponente di una potenza).
. se lo stato è s[] e si raggiunge una virgola o l'inizio della regione di ricerca, selezionare fino a quel punto escluso, escludento ogni sequenza di spazi consecutivi subito a destra di esso.
. se quando lo stato è s[)...],  si incontra ( , cambiare lo stato a [...] e continuare
. se si trova l =  ) ] o } , aggiungerlo davanti ottenendo s[l,),x..] e continuare (similmente per ],});
   • celle di testo: fino al primo spazio.

({{da, x(    x (    a (b[ b)] )   c d , ricavare, x(   ({{y(  [a(b[b)]  ) c}, {\[Placeholder]}})d}})

Forse la questione è più complicata, ma spero che quanto ho detto sia d'aiuto. Fate delle prove con questo:

(∫_a^b)  ((f[x])/(Sqrt[2+((Sin[x])/(1+(x^2)))]))\[DifferentialD]x

Cambiare ed estendere

In una griglia G di dimensioni m×n G si possono usare

(1) Comandi da tasto di controllo
Col cursore in un posto della griglia
 Ctrl[,] crea una colonna (a sinistra  se il cursore è sul bordo sinistro dell'elemento di griglia; altrimenti a destra).
 Ctrl[↵] crea una riga (sopra se il cursore è sul bordo sinistro della primo posto di una riga; altrimenti sotto).

({{ ,  , Ctrl↵       ,  ,  ,  Ctrl[,]    ,  }, {cliccare un asterisco
	    	*, ({{*1, 2}, {3, 4}}), ({{1*, *2*}, {*3, 4}}), ({{1, 2}, {3*, *4*}}), ({{*1, 2}, {*3, 4}}), ({{1*, *2}, {3*, *4}}), ({{1, 2*}, {3, 4*}})}, {ottenere, ({{□, □}, {1, 2}, {3, 4}}), ({{1, 2}, {□, □}, {3, 4}}), ({{1, 2}, {3, 4}, {□, □}}), ({{□, 1, 2}, {□, 3, 4}}), ({{1, □, 2}, {3, □, 4}}), ({{1, 2, □}, {3, 4, □}})}})

({{({{1, 2}}), \[Placeholder]}, {3, 4}, {\[Placeholder], \[Placeholder]}})

In una griglia m×n, selezionare una sottogriglia p × q, H, premere  Ctrl[,]:
	1= q : non cambia niente
	1< q<n: l'elemento in alto a sinistra di H viene rimpiazzato da H; gli altri elementi di H diventano segnaposti.
	1< q=n: H viene rimpiazzato da una singola riga con H nel primo posto e gli altri posti vuoti.
Similmente con Ctrl[↵]
({{- da, ({{1, 2, 3}, {1, 2, 3}, {4, 5, 6}}), ricavare, ({{({{1, 2}, {1, 2}}), □, 3}, {□, □, 3}, {4, 5, 6}}), ({{({{1, 2, 3}, {1, 2, 3}}), □, □}, {4, 5, 6}}), ({{1, ({{2, 3}, {2, 3}}), □}, {1, □, □}, {4, 5, 6}}), ({{({{1, 2, 3}, {1, 2, 3}, {4, 5, 6}}), □}})}})
 ({{e, ({{({{1, 2}, {1, 2}, {4, 5}}), 3}, {□, 3}, {□, 6}}), ({{1, 2, 3}, {({{1, 2}, {4, 5}}), □, 3}, {□, □, 6}}), ({{({{1, 2, 3}, {1, 2, 3}, {4, 5, 6}})}, {□}})}})

(2) Tagliare
Se si seleziona una sottogriglia e la si taglia ( ⌘[X] ) allora: se consiste di righe o colonne intere, viene rimossa, altrimenti i suoi elementi diventano segnaposti.

- da  ({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}})  ricavare le seguenti   ({{□, □, 3}, {□, □, 6}, {7, 8, 9}})   ({{1, 2, 3}, {7, 8, 9}})   ({{1, 3}, {4, 6}, {7, 9}})

(3) Incollare  I soli incollamenti non distruttivi dentro una griglia sono di qualcosa in un singolo posto e di una griglia in una sottogriglia delle stesse dimensioni.
Una griglia P si può incollare in una qualsiasi sottogriglia selezionata più grande H di G:
• P va a rimpiazzare la sottogriglia di H in alto a sinistra delle stesse dimensioni di P 
• Righe o colonne intere di G che siano contenute in H e che non siano toccate dal rimpiazzamento vengono rimosse.
• i posti rimanenti di H fuori dal rimpiazzamento diventano segnaposti.
 
- da  ({{x, x}, {x, x}})  e   ({{•, •, •, •}, {•, •, •, •}, {•, •, •, •}, {•, •, •, •}})  ricavare  ({{•, •, •, •}, {•, x, x, •}, {•, x, x, •}, {•, •, •, •}})   ({{x, x, □, □}, {x, x, □, □}, {•, •, •, •}})     ({{•, x, x}, {•, x, x}, {•, □, □}, {•, □, □}}) 
 
Qualsiasi altro oggetto B può essere incollato in un posto o in una sottogriglia selezionata H di G. 
• B rimpiazza il posto in alto a sinistra di H;
• righe e colonne intere di G che giacciano ineramente dentro H e che non contengono l'elemento in altro a sinistra vengono rimosse
• i rimanenti posti di H diventano segnaposti.
  	
- da (∫_a^b)f(x)dx  e   ({{•, •, •, •}, {•, •, •, •}, {•, •, •, •}, {•, •, •, •}})  ricavare   ({{•, •, •, •}, {•, (∫_a^b)f(x)dx, •, •}, {•, •, •, •}, {•, •, •, •}})     ({{•, (∫_a^b)f(x)dx, •}, {•, □, •}, {•, □, •}, {•, □, •}})    

({{•, •, •, •}, {•, (∫_a^b)f(x)dx, □, □}, {•, □, □, □}, {•, □, □, □}})   ({{(∫_a^b)f(x)dx, •, •}, {□, •, •}, {□, •, •}, {□, •, •}})  ({{(∫_a^b)f(x)dx, □, □, □}, {•, •, •, •}})

(4) Fare cambiamenti con l'Options Inspector
Cambiamenti di dettaglio si possono fare con
Format >Option Inspector(o ⌘|⇧[O])>Formatting Options>Table/Matrix/Palette Formatting
- costruire la cella seguente (l'allineamento delle righe è mostrato a destra, quello delle colonne in fondo):

({{aaaa, (aaa/bbb), 123.36, aaaa, aaaa, alto}, {aaa, (bb/cc), 256, aaa, abcc, basso}, {aa, ((a^p)/((b+(c/(d+(p/r)))))), .67, aa, bb, centro}, {a, ((a^p)/((b+(c/(d+(p/r)))))), 1.678, a, abab, linea di base}, {sinistra, destra, ".", destra, "b",  }})

Allineare testo con un marcatore

Celle di Input

Clear[a,abc]

Qui c'è del testo in una cella di input

A[a , c],
B[abc , cde],
123

- Mettere il carattere invisibiler \[AlignmentMarker] subito dopo ogni carattere c 
- dare l'opzione di cella TextAlignment -> AlignmentMarker.
Si ottiene

A[a , c],
B[abc , cde],
123

• le righe con marcatori si allineano co primo marcatore
	• le altre righe si allineano a sinistra del primo carattere

Un meccanismo di allineamento simile funziona nelle colonne delle griglie in qualsiasi stile di cella, MA l'allineamento per una riga senza marcatore di allineamento è alla destra dell'ultimo carattere, non alla sinistra del primo, e si deve includere "\[AlignmentMarker]" fra i valori di ColumnAlignments (vedi sotto)

Le Colonne delle griglie (in celle di ogni tipo)

Gli allineamenti usati per le colonne sono dati dall'opzione

ColumnAlignments -> {Left,Right,Center,"2","",".","m"}

Se si assegnano allineamenti per la cella, questi si applicano a tutte le griglie della cella che non abbiano singolarmente delle opzioni diverse

({{sinistra, destra, centro, 2,  am , ., m}, {12345, 1213, 1213, 123.0, 191111, 1.22, ambbb}, {12, 23, 23, 111.2344, 1111911, 122., aaamb}, {666, 666, 666, 666, 666, 666, 666}})

Il marcatore di allineamento è a destra dei 9.

Esercizio

Provate a produrre la formula seguente in una cella di testo:

({{ , f(x)+g(x), =, h(x)-q(x)}, {=>, g(x), =, h(x)-q(x)-f(x)}})

In questo caso è meglio assegnare opzioni di griglia a livello di cella o di griglia? A livello di griglia avranno effetto solo su questa griglia; altrimenti su tutte le griglie della cella.

Inserire testo nei grafici

È facile inserire del testo semplice in un grafico come stringa in forma Input, Standard o tradizionale.

Plot[{ 1/(x^2+1),ArcTan[x]},{x,0, 10},
	PlotStyle -> {{},{ Dashing[{.03,.02}]}},
	PlotLabel-> "(1/((x^2) + 1)) e \!\(TraditionalForm\`∫\*FractionBox[\(1\), \(\*SuperscriptBox[\(x\), \(2\)] + 1\)]\\\\ \[DifferentialD]x\) (tratteggiato)"
	];

Si può includere testo colorato via menu, ma non la famiglia o la dimensione del font (sembrerebbe)

Plot[{ 1/(x^2+1),ArcTan[x]},{x,0, 10},
PlotStyle -> {Hue[0.0], Hue[.67]},
	PlotLabel-> "\!\(TraditionalForm\`\(TraditionalForm\`\*
StyleBox[\(1\/\(x\^2 + 1\)\),\nFontColor->RGBColor[1, 0, 0]]\)\) e \!\(TraditionalForm\`\*
StyleBox[\(∫\(1\/\(x\^2 + 1\)\) \[DifferentialD]x\),\nFontColor->RGBColor[0, 0, 1]]\)"
	]

Altri effetti speciali richiedono una scrittura esplicita:

Plot[{(1/((x^2)+1)),ArcTan[x]},{x,0,10},PlotLabel->DisplayForm[RowBox[{StyleBox[MakeBoxes[(1/((x^2)+1))],FontFamily->"Times",FontSize->12,FontColor->Hue[0]]," e ",FormBox[StyleBox[MakeBoxes[∫(1/((x^2)+1))\[DifferentialD]x],FontColor->Hue[0.67`],FontFamily->"Times",FontSize->18],"TraditionalForm"]}]],PlotStyle->{Hue[0],Hue[0.67]}];

Plot[x,{x,0,2}, PlotLabel :> DisplayForm[
    RowBox[{"x", " ",FormBox[StyleBox[ToBoxes[ Integrate[x,x]],
						FontColor ->Hue[.8],FontFamily->"Times",
						FontSize->18],"TraditionalForm"],
					
      StyleBox["y",
        FontColor->RGBColor[1, 0, 0]]}]]];

Esempi di formattazione

Allineamento

La formula seguente usa una griglia 3 per 2 con ColumnAlignments->{"="})

({{ab=c+b}, {e+f=r}, {f+g+h=r}})

Matrici (griglie)

Molte richiedono aggiustamenti nelle parentesi avvolgenti

(({{n+1}, {x}})) ,   [({{c}, {d}})] ,  |({{1, 0}, {0, 1}})|

[({{c}, {d}})]

S=({{, ({{(Subscript[I, m]), O, L}})}, {({{(Subscript[I, m])}, {O}, {L}}), (({{1, 0, 0}, {λ, 1-λ, 0}, {0, λ, 1-λ}}))}})

x={({{(1/2), n=0}, {(∫_0^1)(y^n)dy, n>0}, {-(n^2), n<0}})

(({{1, 0, …, 0}, {0, 1, …, 0}, {⋮, ⋮, ⋱, ⋮}, {0, 0, …, 1}}))

(Overscript[H, ↔])≈[({{(((∂^2)Ω)/(∂(x^2))), 0}, {0, (((∂^2)Ω)/(∂(y^2)))}})]

Posizionamento dei limiti di somme, integrali ecc. all'interno del testo

La posizione di default è (∑_(r=0)^x)y, anche usando Ctrl[=]; però si può ottenere (∑_(r=0)^x)y usando l'opzione LimitsPositioning->False nella UnderoverscriptBox. (a tutt'oggi questa opzione va inserita manualm nella espressione di cella come segue: (si passa dalla cella alla sua espressione soggiacente e viceversa col menu Format>Show Expression)

Cell[TextData[Cell[BoxData[
    FormBox[
      RowBox[{
        UnderoverscriptBox["\[Sum]", 
          RowBox[{"r", "=", "0"}], "x",
          LimitsPositioning->False], "y"}], 
      TraditionalForm]]]], "Text"]

Integrali

(((({(∫_a^b)((∑_(i=1)^m)(Subscript[λ, i])(x)))^p)dx})^(1/p))≤(∑_(i=1)^m)(({(∫_a^b)((((Subscript[λ, i])(x))^p))dx})^(1/p))

(((({(∫_a^b)((∑_(i=1)^m)(Subscript[λ, i])(x)))^p)\[DifferentialD]x})^(1/p))≤(∑_(i=1)^m)(({(∫_a^b)((((Subscript[λ, i])(x))^p))\[DifferentialD]x})^(1/p))

(∫_a^b)f(x)\[DifferentialD]x   (Underscript[△, =])   (lim_(n–->∞))((b-a)/n)(∑_(r=1)^nf)(a+(r/n)(b-a))

Prescritti

Il prescritto + qui sotto è fatto mettendo un superscritto a uno spazio.

+(Subscript[H, 1         ])

(Subscript[, 92]) (U^329)+(Subscript[, 0]) (n^1)  =  (Subscript[, 92]) (U^239)

Frecce e soprascritti

(OverBar[X])+(OverBar[Y])

(OverBar[(OverBar[X])+(OverBar[Y])])=X(Overscript[+, •])Y

(Overscript[AB, ⟶])+(Overscript[BC, ⟶])=(Overscript[AC, ⟶])

Valutazione in loco

La cella di testo che segue è stata creata con la valutazione in loco, che funziona sia nel testo che nell'input.

∫((3 (x^2)+2 x+4)/((((x-1))^2) ((x^2)+1)))dx 
	
	= -(tan^(-1))(x)-(9/(2 (x-1)))-(1/2) log(x-1)+(1/4) log((x^2)+1)
 12345 = 3*5* 823
5(x^5)+5(x^4)-10(x^3)-10(x^2)+5x+5 = 5 (((x-1))^2) (((x+1))^3)

University of Rutland
B.Sc Examination

Mixed Mathematics - paper 1

(3 hours)

The use of a non-programmable electronic calculator is permitted in this examination. Please state on your answer paper the make and type of machine used.

1.	The position vectors of the points A, B, C, with respect to a fixed point are defined by:

(Overscript[OA, →])=(1+t)i+tj-2tk
				(Overscript[OB, →])=(3+t)i+12tj+(1-3t)k
				(Overscript[OB, →])=(1+3t)i+2j+(2-t)k

at a time t, where i, j, k are three fixed mutually perpendicular unit vectors.
	Find when the area of the triangle is at a minimum.

2.	A time varying system is governed by the equation (OverDot[(UnderBar[x])])=[({{0, 1}, {0, t}})](UnderBar[x])
.
	Show that the transition matrix is Φ(t,(Subscript[t, 0]))=[({{1, (∫_(Subscript[t, 0]^t))g(u,(Subscript[t, 0]))}, {0, g(u,(Subscript[t, 0]))}})]
	where g(t,(Subscript[t, 0]))=exp[(1/2)((t^2)-(Subscript[t, 0]^2))]

3.	Evaluate the following limits:
				(a)	(lim_(u->0))((((Sqrt[x+u])-(Sqrt[x]))/u))	
				
				(b)	(lim_(x->0))(((6(x cos(x)-sin(x))+2(x^3))/(x^5)))