Dues regles com per exemple \(S \rightarrow aS\) i \(S \rightarrow X\) es poden representar de forma agrupada de la següent manera: \(S \rightarrow aS | X\).

En una gramàtica sempre hi ha una variable (normalment la primera que apareix) que anomenem símbol inicial. Les paraules generades per la gramàtica són aquelles formades per terminals a les quals es pot arribar des del símbol inicial.

Podem representar les substitucions necessàries per arribar a una paraula amb la sintaxi ja coneguda, o bé en forma d’arbre (arbre de derivació o arbre sintàctic).

Les gramàtiques incontextuals també es poden representar formalment com una tupla \(G=\langle{}V,\Sigma,\delta,S\rangle\).

Un llenguatge s’anomena llenguatge incontextual si existeix una gramàtica que el genera. Existeixen algorismes \(O(n^3)\) per comprovar si una paraula és generable per una gramàtica i generar-ne l’arbre sintàctic. Això és útil per a compiladors i intèrprets.

Quan una gramàtica permet més d’un arbre de derivació per a una paraula diem que és ambigua. Això no és desitjable quan volem utilitzar la gramàtica per interpretar el significat de les entrades.

Un criteri per determinat l’ambigüitat quan només utilitzem regles lineals (on cada alternativa de la part dreta només inclou una única variable): si no existeixen dues alternatives amb que es pugui generar el mateix, llavors la regla no genera ambigüitat.

Operacions sobre gramàtiques

Els llenguatges incontextuals estan tancats per unió: Tenim dues CFG \(G_1\) i \(G_2\) que generen els llenguatges \(\mathcal{L}(G_1)=L_1\) i \(\mathcal{L}(G_2)=L_2\). Suposem que els llenguatges no comparteixen variables (si no fos així, les podem reanomenar). Si definim la operació unió de gramàtiques \(G_1\cup G_2=\langle V_1 \cup V_2 \cup \{S\}, \Sigma_1 \cup \Sigma_2, \delta_1 \cup \delta_2 \cup \{S \rightarrow S_1|S_2, S\}\rangle\) llavors aquesta compleix \(\mathcal{L}(G_1 \cup G_2) = \mathcal{L}(G_1) \cup \mathcal{L}(G_2) = L_1 \cup L_2\).

També ho són per concatenació. Amb les mateixes condicions que abans, \((G_1\cdot G_2)=\langle V_1 \cup V_2 \cup \{S\}, \Sigma_1 \cup \Sigma_2, \delta_1 \cup \delta_2 \cup \{S \rightarrow S_1S_2\}, S\rangle\) compleix \(\mathcal{L}(G_1\cdot G_2)=\mathcal{L}(G_1)\cdot \mathcal{L}(G_2)=L_1\cdot L_2\).

Per l’operació estrella: \(G^*=\langle V \cup \{S’\}, \Sigma, \delta \cup \{S’ \rightarrow S’S|\lambda\}, S’\rangle\) compleix \(\mathcal{L}(G^*)=\mathcal{L}(G)^*=L^*\).

Per l’operació revessat: \(G^R=\langle V, \Sigma, \{X \rightarrow u^R | (X \rightarrow u) \in \delta\}, S’\rangle\) compleix \(\mathcal{L}(G^R)=\mathcal{L}(G)^R=L^R\) ja que \(\forall X \in V, \mathcal{L}(G, X)^R \subseteq \mathcal{L}(G^R,X)\).

I per imatge de morfisme: \(L \in CFL\) i \(\sigma: \Sigma_1 \rightarrow \Sigma_2\) tal que \(\sigma(uv)=\sigma(u)\sigma(v) \Rightarrow \sigma(L) \in CFL\). En aquest cas a la tupla de la gramàtica resultant es substitueix \(\delta\) per \(\{X\rightarrow \sigma(u) | (X \rightarrow u) \in \delta\}\).

En canvi, no són tancats per intersecció (si \(L_1, L_2 \in CFL \nRightarrow (L_1 \cap L_2) \in CFL\)) ni complementari.

Aquests apunts estan basats en els vídeos de Teoria de la Computació de Guillem Godoy (UPC).

Related posts:

1. Apunts de Teoria de la Computació: Teoria de llenguatges Un alfabet () és un conjunt finit d’elements (símbols), habitualment...

Un mot és una llista de símbols d’un alfabet. El mot buit (llista de longitud 0) el denotarem amb el meta-símbol \(\lambda\). Utilitzarem \(u\), \(v\), \(w\), \(u_1\), … per denominar paraules.

\(\Sigma = \{a, b\}\)
Paraules: ab, bbb, a, \(\lambda\)
Longituds: |ab|=2, |bbb|=3, |a|=1, |\(\lambda\)|=0

Extenem la notació de les longituds per a occurències d’un mot dins d’un altre: \(|u|_w\)

\(|ab|_a=1\), \(|bbb|_b=3\), \(|bbb|_{bb}=2\)

Per referir-nos al símbol i-éssim del mot u utilitzarem: u[i]

ab[1] = a, ab[2] = b

Amb la operació producte (\(u\cdot v\) o \(uv\)) representem la concatenació de dues paraules. Per exemple:

\((ab)\cdot(bbb) = abbbb\)
Element neutre: \(u\cdot\lambda=\lambda\cdot u=u\)
Associativitat: \(u\cdot(v\cdot w)=(u\cdot v)\cdot w\)

Amb \(\Sigma^*\) representem el conjunt de tots els mots possibles que podem construir amb l’alfabet \(\Sigma\). Exemple per a \(\Sigma = \{a, b\}\):

\(\Sigma^*={\lambda, a, b, aa, ab, ba, bb, …}\)

Un llenguatge sobre l’alfabet \(\Sigma\) és un subconjunt qualsevol \(L^* \subseteq \Sigma^*\). Per exemple:

• Paraules sobre l’alfabet {a, b} i de longituds múltiples de 2:
     \(\{w \in \{a, b\}^* / |w| \in \dot{2}\} = \{\lambda, aa, ab, ba, bb, aaaa, …\}\)
• Paraules amb algun símbol «a»:
     \(\{w \in \{a,b\}^* / \exists w_1,w_2 : w = w_1aw_2\} = \{w \in \{a, b\}^* / |w|_a \ge 1\}\)
• Paraules tals que tota ocurrència d’«a» ve seguida d’una occurència de «b»:
     \(\{w \in \{a,b\}^* / \forall w_1, w_2 : (w=w_1aw_2 \Rightarrow \exists w_2^1 : w_2 = bw_2^1) = \)
     \( = \{w \in \{a, b\}^* / |w|_{aa}=0\land(w=\lambda \lor \exists w’ : w=w’b)\}\)

---

Denotem el llenguatge que conté només el mot buit amb \(\Lambda=\{\lambda\}\) (\(\Lambda \neq \emptyset\)).

Definim la concatenació de dos llenguatges:

\(L_1\cdot L_2 = \{w_1\cdot w_2 / w_1 \in L_1 \land w_2 \in L_2\}=\) \(\{w / \exists w_1 \in L_1, w_2 \in L_2 : (w=w_1w_2)\}\)

Exemples:

\(\{a,bb\}\cdot\{b,ba\} = \{ab, aba, bbb, bba\}\)
Element neutre: \(\Lambda\cdot L = L \cdot \Lambda = L\)
No funciona amb el conjunt buit: \(\emptyset\cdot L=L\cdot \emptyset = \emptyset\)
Associativitat: \(L_1(L_2L_3)=(L_1L_2)L_3\)

Definim l’exponenciació de paraules:

\(w^n=w\cdot w\cdot \cdot\cdot\cdot \cdot w\)

Exemples:

\(w^2=ww\) \(w^1=w\) \(w^0=\lambda\)

Es compleix que: \(w^n=w\cdot w^{n-1}\), \(n\ge 1\).

Ídem per a l’exponenciació de llenguatges.

Definim també l’operació \(L^*\) (clausura de Kleene) d’un llenguatge. Aquesta dóna com a resultat un nou llenguatge que conté aquelles paraules que es poden obtenir a base d’escollir un nombre finit de paraules d’L i concatenar-les.

\(
\begin{array}{ll}L^*
& = \{w_1\cdot w_2\cdot \cdot\cdot\cdot \cdot w_n / w_1, w_2, …, w_n \in L\} \\
& = \{L^0\cup L^1\cup L^2\cup …\}\\
& = \prod_{n=0}^{\infty}L^n\\
\end{array}
\)
(Les paraules d’\(L^*\) són concatencions de 0, 1, 2, … paraules d’L.)

Per exemple:

\(\{a\}^* = \{\lambda, a, aa, aaa, …\}\)
\(\{ab\}^* = \{\lambda, ab, abab, ababab, …\}\)
\(\{a, bb\}^* = \{\lambda, a, bb, aa, abb, bba, bbbb, …\}\)
\(\{w\in\{a,b\}^* / |w| \in \dot{2}\}^* = \{w\in\{a,b\}^* / |w| \in \dot{2}\}\)

De forma semblant definim l’operació \(L^+\), la qual no obliga a incloure el mot buit.

\(L^+ = L^1\cup L^2\cup…\)
\(L^* = L^+ \cup \{\lambda\}\)
\(\lambda \in L^+ \Leftrightarrow \lambda \in L\)

---

Denominem el revessat d’un mot \(w\): \(w^R\). Exemple:

\((aabab)^R=babaa\)

El revessat de la concatenació de dues paraules correspon al revessat de les dues paraules:

\((uv)^R=v^Ru^R\)

També tenim el revessat d’un llenguatge:

\(L^R = \{w^R / w \in L\} = \{w | w^R \in L\}\)
\((L_1L_2)^R=L_2^RL_1^R\)

Per exemple:

\(\{aw | w \in \{a, b\}^*\}^R = \{wa | w \in \{a,b\}^*\}\)

Definim un morfisme com una funció que transforma paraules d’un alfabet a un altre:

\(\sigma: \Sigma_1^* \rightarrow \Sigma_2^*\)
Commutativa amb la concatenació: \(\sigma(uv) = \sigma(u)\sigma(v)\)

\(\sigma(a_1a_2\cdot\cdot\cdot a_n)=\sigma(a_1)\sigma(a_2)\cdot\cdot\cdot\sigma(a_n)\)
\(\sigma(\lambda)=\lambda\)

Gràcies a la commutativitat, tenim prou per definir un morfisme amb definir la imatge dels símbols de l’alfabet, ja que llavors l’imatge de qualsevol mot es pot calcular en termes de les imatges dels símbols.

Per exemple:

\(\sigma: \{a, b, c\}^* \rightarrow \{0, 1\}^*\)
\(\sigma(a) = 0\), \(\sigma(b)=11\), \(\sigma(c)=\lambda\)

\(\begin{array}{ll}
\sigma(accbacb)
& = \sigma(a)\sigma(c)\sigma(c)\sigma(b)\sigma(a)\sigma(c)\sigma(b) \\
& = 0\lambda\lambda110\lambda11 \\
& = 011011
\end{array}
\)

Per a un llenguatge L:

\(\sigma: \Sigma_1^* \rightarrow \Sigma_2^*\)
\(L \subseteq \Sigma_1^*\)   \(\sigma(L)=\{\sigma(w) / w \in L\}\)
\(L \subseteq \Sigma_2^*\)   \(\sigma^{-1}(L) = \{w / \sigma(w) \in L\}\)
\(\sigma(L_1L_2) = \sigma(L_1)\sigma(L_2)\)

Una regla de reescriptura (o substitució) és un parell de paraules \(u\rightarrow v\). Per exemple, la regla \(ab \rightarrow bba\) substitueix tota ocurrència d’«ab» per «bba».

Representem una substitució de la forma \(w_1uw_2 \rightarrow_{u\rightarrow v} w_1vw_2\). Per exemple:

\(a\underline{ab}ab \rightarrow_{ab\rightarrow bba} a\underline{bba}ab\)

Si R és un conjunt de regles, podem indicar que \(w\) es transforma en \(w’\)…

\(w\rightarrow_R w’\)	\(w\rightarrow_R^* w’\)	\(w\rightarrow_R^+ w’\)	\(w\rightarrow_R^i w’\)
aplicant 1 regla d’R	aplicant 0 o mes substitucions amb regles d’R	aplicant 1 o més substitucions amb regles d’R	aplicant \(i\) substitucions amb regles d’R

Aquests apunts estan basats en els vídeos de Teoria de la Computació de Guillem Godoy (UPC).

Related posts:

1. Apunts de Teoria de la Computació: Gramàtiques incontextuals Una gramàtica incontextual (CFG, Context Free Grammar) és un conjunt...
2. Apunts de Càlcul: Funcions d’una variable Introducció Considerem una funció real de variable real tal que...
3. Apunts d’Estructures de Dades i Algorismes: Càlcul de costs Introducció Els algorismes són per tot arreu i per això...

Els tres mons

Món conceptual

Classes d'objectes: quelcom real, identificable i distingible.

… [FIXME: imatge diagrama UML] …

Món de les representacions

El més obvi seria utilitzar fitxers (i directoris), però aquests no es permeten representar associacions tal com nosaltres volem. Per aquest motiu, neix el concepte de base de dades: un conjunt estructurat de dades que permet representar classes d'objectes i les seves associacions amb integració (sense repeticions) i compartició (molts usuari alhora) de dades.

Evolució:

• Model jeràrquic: arbres (IBM). Tenen el problema que un fill pot tenir només un sol pare.
• Model en xarxa: xarxes.
• Model relacional (1969, Codd): taules.

SGBD (DBMS)

Un sistema gestor de bases de dades (database management system) és un programa complex que facilita la representació de classes d'objectes i les seves associacions i diverses tasques de gestió de dades als programes d'aplicació. Nosaltres utilitzarem el PostgreSQL.

El model relacional

Objectius i origens

Origen: E. F. Codd, 1969.

Primers prototipus: al començament dels anys 80.

Objectius: Facilita que la base de dades sigui percebuda com una estructura lògica independent de l'estructura física, simple i uniforme.

Estructura de les dades

Una relació es compon de:

• Esquema de la relació (intensió) (capçalera)
  És el nom de la relació i els seus atributs. Per exemple: «estudiants(codi, dni, nom, telèfon)».
  • Atribut: és el paper o rol que juga un domini en una relació.
  • Domini: és un conjunt de valors atòmics. Per exemple: «int», «char(30)», etc.
  • Valors nuls: (SQL: NULL) desconegut i inaplicable.
• Extensió de la relació
  L'extensió d'una relació d'esquema R(A1, A2, …, An) és un conjunt de tuples Tj=<V11, V12, …, Vn>, on Vij és un valor del domini d'Aj o bé un valor nul.
  • Tupla: és un element de l'extensió de la relació.
  • Grau: és el nombre d'atributs d'una relació.
  • Cardinalitat: és el nombre de tuples d'una relació.

Una relació ha de contenir valors atòmics (un sol valor), no hi ha tuples repetides i no hi ha ordre entre les tuples ni entre els atributs.

Superclau: és un subconjunt dels atributs de l'esquema de la relació que identifica les tuples de l'extensió de la relació.

Clau (claus candidates): és una superclau d'una relació que no té cap subconjunt propi que sigui alhora superclau. Es divideixen en la clau primària (la clau candidata que hagi estat escollida) i claus secundàries o alternatives.

Clau forana: subconjunt dels atributs de l'esquema de la relació que referencia una clau primària d'una altre relació o de la pròpia relació.

Regles d’integritat

• Regla d’integritat d’entitat

  Una clau primària d’una relació no pot tenir ni valors nuls ni valors repetits.

• Regla d’integritat referencial

  Els valors d’una clau forana poden ser només valors de la clau primària referenciada o valors nuls.

  Polítiques d’actuació en cas d’esborrat o modificació de claus primàries amb claus foranes referenciant-les:

  • Restricció: no es permet esborrar o modificar una clau primària referenciada per claus foranes (SQL: RESTRICT / NOACTION).
  • Actualització en cascada: en cas d’esborrar o modificar una clau primària referenciada en alguna clau forana, s’esborren o modifiquen totes les referències (SQL: CASCADE).
  • Anul·lació: en cas d’esborrar o modificar una clau primària referenciada s’assignen valors nuls a totes les referències (SQL: SET NULL / SET DEFAULT).

• Regla d’integritat de domini

  1. Un valor no nul d’un atribut ha de pertànyer al domini de l’atribut.
  2. Les operacions que es poden aplicar sobre els valors depenen dels dominis dels valors.

Àlgebra relacional

Components lògics d’una base de dades

Un esquema, per a un SGBD, és un conjunt definit i relacionat de components de dades i components de control.

CREATE SCHEMA nom_esquema
AUTHORIZATION identitat_usuari
[llista d'elemens de l'esquema]

DROP SCHEMA nom_esquema RESTRICT/CASCADE

CREATE DATABASE
CREATE DM

Connexions

CONNECT TO nom_servidor [AS nom_connexió] [USER ...]
DISCONNECT nom_connexió DEFAULT/CURRENT/ALL

Sessió

SET SESSION CHARACTERISTICS AS mode_trans

Transaccions

SET TRANSACTION mode_trans / START TRANSACTION
mode_trans: mode d'accés / nivell d'aïllament (READONLY / READ WRITE)

COMMIT: s'accepta tot.

ROLLBACK: no s'accepta res (es desfan els canvis).

Dominis

CREATE DOMAIN ciutats AS CHAR(15)
DEFAULT 'BCN'
CONSTRAINT ciutats_valides CHECK VALUE IN ('BCN', 'GIR', 'TGN')

Taules

CREATE TABLE empleats(
  codi_empl INTEGER PRIMARY KEY,
  nom_empl VARCHAR(30),
  dni CHAR(8) UNIQUE,
  sou REAL NOT NULL,
  data_naix DATE CONSTRAINT naix_impossible CHECK (data_naix >= 01/01/1900),
  data_jubilacio DATE,
  ciutat_resid CIUTATS,
  dept INTEGER DEFAULT 1 REFERENCES departaments(id)

Aquesta última referència també s’hauria pogut especificar al final:

FOREIGN KEY (dept) REFERENCES departaments(id) [ON DELETE ...] [ON UPDATE ...]

Assercions

Ens permeten definir restriccions d’integritat a més d’una taula. Es comproven sempre. SQL:

CREATE ASSERTION nom CHECK (condition)

No estan implementades en cap SBGD, ja que disposen de TRIGGER (disparadors) que permeten la mateixa funcionalitat i són més potents.

Vistes (esquemes externs)

Una vista és una relació (es pot consultar i actualitzar) derivada (no existeix físicament, sinó que és virtual).

CREATE VIEW nom (nom_col1, nom_col2, ...., nom_coln) AS  [WITH CHECK OPTION]

Procediments (PL/pgSQL)

CREATE FUNCTION troba_ciutat(dni_ciutat VARCHAR(9)) RETURNS VARCHAR(15) AS $$
DECLARE
  ciutat_client VARCHAR(15);
BEGIN
  SELECT ciutat INTO ciutat_client
    FROM empleats
    WHERE dni=dni_client;
  RETURN ciutat_client;
END;
$$LANGUAGE plpgsql;

Disparadors (triggers)

CREATE TRIGGER nom_disparador
  BEFORE UPDATE ON nom_taula
  FOR EACH ROW EXECUTE PROCEDUR acció;

Privilegis

GRANT privilegis ON objectes TO usuaris [WITH GRANT OPTION]
REVOKE [GRANT OPTION FOR] privilegis ON objects FROM usuaris [CASCADE|RESTRICT]
GRANT PUBLIC ...

CREATE ROLE nom;
SET ROLE nom;

Traducció de disseny a model relacional

La següent taula resumeix com transformar els elements d’un disseny UML per tal d’implementar-lo com a base de dades en un SGBD:

Transaccions i concurrència

Transaccions

ACID: atomicitat, consistència, «isolació», durabilitat.

Tipus d’interferències entre transaccions:

• actualització perduda (doble actualització)
• lectura no confirmada
• lectura no repetible
• anàlisi inconsistent
• fantasmes

Serialitzabilitat

La teoria de la serialitzabilitat defineix de manera precisa les condicions que s’han de complir per considerar que les transaccions estan aïllades entre si correctament.

…

Related posts:

1. Apunts d’Estructures de Dades i Algorismes: Diccionaris Introducció Són un tipus abstracte de dades (TAD), és a...
2. Apunts d’Estructures de Dades i Algorismes: Les classes de problemes P i NP Classes de problemes – P i NP Entrades Problemes Classes...
3. Apunts d’Estructures de Dades i Algorismes: Programació dinàmica 1. Nombres de Fibonacci L'algorisme trivial per al càlcul dels...

Com trobar els valors?

	\( \begin{array}{ll} \sin45º & =\frac{1}{\sqrt{2}}=\frac{\sqrt{2}}{2} \\ \cos45º & =\frac{1}{\sqrt{2}}=\frac{\sqrt{2}}{2} \\ \tan45º & =1 \\ \end{array}\)
	\( \begin{array}{ll} \sin30º & =\frac{1}{2} \\ \cos30º & =\frac{\sqrt{3}}{2} \\ \tan30º & =\frac{1}{\sqrt{3}} \\ \end{array}\)
	\( \begin{array}{ll} \sin60º & =\frac{\sqrt{3}}{2} \\ \cos60º & =\frac{1}{2} \\ \tan60º & =\sqrt{3} \\ \end{array}\)

Taula resum

Related posts:

1. Apunts de Càlcul: Nombres reals i nombres complexos 1. Nombres reals Naturals Propietats: Propietats: Enters La suma també...

Considerem una funció real de variable real \(f: A \in \mathbb{R} \rightarrow \mathbb{R}\) tal que \(\forall x \in A\) existeix com a màxim un \(y \in \mathbb{R} : y=f(x)\). Definim:

Definim el domini d’una funció:
\(\operatorname{Dom} f = \left\{x \in \mathbb{R} / \exists f(x) \in \mathbb{R}\right\} = \left\{x \in \mathbb{R} / \exists y \in \mathbb{R} / y=f(x)\right\}\)

I el recorregut d’una funció:
\(\operatorname{Im} f = \left\{f(x) / x \in \operatorname{Dom} f\right\} = \left\{y \in \mathbb{R} / \exists x \in \operatorname{Dom} f / y=f(x)\right\}\)

També: \(\operatorname{Graf}(f) = \left\{(x,y) / x \in \operatorname{Dom} f\right\}\) 

Exemple

Tipus de funcions

Una funció \(\begin{array}{ll}f: & \mathbb{R} \rightarrow \mathbb{R} \\ & x \mapsto f(x)\end{array}\):

1. és parella \(\Leftrightarrow \forall x \in \operatorname{Dom} f, f(-x) = f(x)\)
2. és imparella \(\Leftrightarrow \forall x \in \operatorname{Dom} f, f(-x) = -f(x) \)
3. és periòdica de període \(w \in \mathbb{R}\) \(\Leftrightarrow \forall x \in \operatorname{Dom} f, \begin{cases}f(x+w) = f(x) \\ \forall k \in \mathbb{Z}, f(x+kw)=f(x)\end{cases}\)
4. és creixent (no decreixent) \(\Leftrightarrow \forall x,y \in \operatorname{Dom} f, x < y \Rightarrow f(x) \le f(y) \)
5. és estrictament creixent \(\Leftrightarrow \forall x, y \in \operatorname{Dom} f, x < y \Rightarrow f(x) < f(y) \)
6. és decreixent \(\Leftrightarrow \forall x,y \in \operatorname{Dom} f, x < y \Rightarrow f(x) \ge f(y)\)
7. és estrictament decreixent \(\Leftrightarrow \forall x,x \in \operatorname{Dom} f, x < y \Rightarrow f(x) > f(y)\)
8. està acotada superiorment \(\Leftrightarrow \exists k \in \mathbb{R} / \forall x \in \operatorname{Dom} f, f(x) \le k\)
9. està acotada inferiorment \(\Leftrightarrow \exists m \in \mathbb{R} / \forall x \in \operatorname{Dom} f, f(x) \ge m\)
10. està acotada \(\Leftrightarrow \exists k \in \mathbb{R} / \forall x \in \operatorname{Dom} f, |f(x)| \le k\)
11. és injectiva \(\Leftrightarrow \forall x_1, x_2 \in \operatorname{Dom} f, x_1 \ne x_2 \Rightarrow f(x_1) \ne f(x_2)\)
12. és exhaustiva \(\Leftrightarrow \begin{array}{l}\operatorname{Im} f = \mathbb{R} \\ \forall y \in \mathbb{R}, \exists x \in \operatorname{Dom} f / y = f(x)\end{array}\)
13. és bijectiva \(\Leftrightarrow\) és injectiva i exhaustiva (\(\forall y \in \mathbb{R}, \exists!x / f(x)=y\))

Operacions amb funcions

Composició de funcions

\(f\circ g \;\;\;\;\;\; \begin{array}{l}\mathbb{R} \rightarrow \mathbb{R} \\ x \mapsto (f\circ g)(x)=f(g(x))\end{array}\) 

Funció inversa

Asímptotes

\(x=a\) és una asímptota vertical de la funció \(f \Leftrightarrow \lim_{x \to a} (x) = \begin{cases}+\infty \\ -\infty \\ \infty\end{cases}\)
\(x=b\) és una asímptota horizontal… per la dreta \(\Leftrightarrow \lim_{x \to +\infty} f(x) = b\) per l’esquerra \(\Leftrightarrow \lim_{x \to -\infty} f(x) = b\)
\(y=mx+n\) és una asímptota oblíqua… per la dreta d’\(y=f(x) \Leftrightarrow m=\lim_{x \to +\infty} \frac{f(x)}{x}\) i \(m=\lim_{x \to +\infty}(f(x)-mx)\) per l’esquerra (igual que per la dreta però amb \(-\infty\))

Continuïtat

Tipus de punts de discontinuïtat d’una funció

Derivabilitat

\(\begin{array}{l}\begin{array}{l?}f: & \mathbb{R} \rightarrow \mathbb{R} \\ & x \mapsto f(x)\end{array} \\ a \in \operatorname{Dom}f\end{array}\)	\(f\) és derivable en \(a\) si \(\exists \lim_{x \to a} \frac{f(x)-f(a)}{x-a} \in \mathbb{R}\). Aquest és igual a \(\lim_{h \to 0} \frac{f(a+h) – f(a)}{h}\) = \(f’(a)\) = pendent de la recta tangent a la curva \(y = f(x)\) en el punt d’abscissa \(a\), \((a, f(a))\).
	Recta tangent a \(y=f(x)\) on el punt d’\(x=a\): \(y=f(a)+f’(a)(x-a)\).

Related posts:

1. Apunts de Càlcul: Nombres reals i nombres complexos 1. Nombres reals Naturals Propietats: Propietats: Enters La suma també...
2. Apunts d’Estructures de Dades i Algorismes: Càlcul de costs Introducció Els algorismes són per tot arreu i per això...
3. Apunts de Teoria de la Computació: Teoria de llenguatges Un alfabet () és un conjunt finit d’elements (símbols), habitualment...

Naturals \(\mathbb{N}=\left\{1,2,3,4,…\right\}\)

Enters \(\mathbb{Z}=\left\{…,-1,0,1,…\right\}\)

Racionals \(\mathbb{Q}=\left\{\frac{a}{b} | a,b \in \mathbb{Z}, b \ne 0\right\}\)

Irracionals \(\mathbb{I}=\mathbb{R}-\mathbb{Q}\)

Reals \(\mathbb{R} = \mathbb{Q} \cup \left\{\mathbb{R}-\mathbb{Q}\right\}\)

Relació d’ordre en \(\mathbb{R}\)

\(\begin{array}{ll}
1.\; \forall x & x \le x \\
2.\; \forall x,y & (x \le y \land y \le x) \Rightarrow x=y \\
3.\; \forall x,y,z & \begin{cases}x \le y \\ y \le z\end{cases} \Rightarrow x \le z \\
4.\; \forall x,y & x \le y \lor y \le x \\
5.\; \forall x,y,z \in \mathbb{R} & x \le y \Rightarrow x+z \le y+z \\
6.\; \forall x,y \in \mathbb{R}, \forall z \in \mathbb{R}, z \ge 0 & x \le y \Rightarrow xz \le yz \\
7.\; \forall x,y \in \mathbb{R}, \forall z \in \mathbb{R}, z < 0 & x \le y \Rightarrow xz \ge yz \\
8.\; x < y \Leftrightarrow \begin{cases}x \le y \\ x \ne y\end{cases}
\end{array}\)

Elements notables d’un conjunt respecte de la \(\le\)

A està acotat inferiorment \(\Leftrightarrow \exists x \in \mathbb{R}\) / \(x\) és cota inferior d’A.
A està acotat superiorment \(\Leftrightarrow \exists x \in \mathbb{R}\) / \(x\) és cota superior d’A.
A està acotat \(\Leftrightarrow\) A està acotat superiorment i inferior.

x és el ínfim d’A \(\Leftrightarrow\) x és la major de les cotes inferiors d’A \(\to x = \inf A\).
x és el suprem d’A \(\Leftrightarrow\) x és la menor de les cotes superior d’A \(\to x = \sup A\).

Teorema de l’extrem (també axioma del suprem) \(\leftarrow \begin{cases}es\;compleix\;en\;\mathbb{R} \\ no\;es\;\;compleix\;en\;\mathbb{Q}\end{cases}\)

\(A \subseteq \mathbb{R}, A\) acotat superiorment \(\Rightarrow \exists x \in \mathbb{R}\) / \(x=sup A\)
\(A \subseteq \mathbb{R}, A\) acotat inferiorment \(\Rightarrow \exists x \in \mathbb{R}\) / \(x=inf A\)

Valor absolut

Propietats:

\(\begin{array}{ll}
1.\; \forall x & |x| \ge 0 \\
2.\; & |x| = 0 \Rightarrow x = 0 \\
3.\; \forall x,y & |x+y| \le |x| + |y| \\
4.\; \forall x,y & |x\cdot y| = |x| \cdot |y| \\
5.\; a > 0 & |x| < a \Leftrightarrow -a < x < a \Leftrightarrow x \in (-a, a) \\
6.\; a > 0 & |x| > a \Leftrightarrow x \le -a \lor x > a
\end{array}\)

2. Nombres complexos

La «unitat imaginària» és \(\sqrt{-1}=i\).

Els nombres complexos són els nombres \(a+bi\), amb \(a,b \in \mathbb{R}\).

Conjunt dels nombres complexos: \(\mathbb{C} = \left\{a+bi | a,b \in \mathbb{R^2}\right\}\).

Donat \(z=a+bi \; \begin{cases}a = part\;real\;del\;nombre\;complex\;z \\ b=part\;imaginària\;del\;nombre\;complex\end{cases}\)

Donat \(z=a+bi\), diem que el conjugat de \(z\) és \(\overline{z}=a-bi\).

En \(\mathbb{C}\), \(ax^2+bx+c=0\) amb \(a,b,c \in \mathbb{R}\), sempre té solució en \(\mathbb{C}\). Exemple:

\(x^2-4x+8=0 \Rightarrow x = \frac{4\pm\sqrt{16-32}}{2} = \frac{4 \pm \sqrt{-16}}{2} = \frac{4\pm4i}{2} = \begin{cases}2+2i \\ 2-2i\end{cases}\)
(Recorda: \(\sqrt{ab}=\sqrt{a}\sqrt{b}\))

Operacions

Suma

\(\begin{cases}z_{1}=a+bi \\ z_{2}=c+di\end{cases} \;\;\;\;\;\; z_1+z_2=(a+c)+(b+d)i\)

Producte

\(z_1z_2 = (a+bi)(c+di) = ac + adi + bci + bdi^2 = (ac-bd)+(ad+bi)i\)
(Recorda: \(i^2=-1\))

\((\mathbb{C}, +, \cdot)\) és un cos commutatiu.

L’invers de \(z=a+bi \ne 0\) és \(\frac{1}{z}=\frac{1}{a+bi}=\frac{(a-bi)}{(a+bi)(a-bi)}=\frac{a-bi}{a^2-(bi)^2}=\frac{a-bi}{a^2-b^2i^2}=\) \(\frac{a-bi}{a^2+b^2}=\frac{a}{a^2+b^2}-\frac{b}{a^2+b^2}i\)

Quocient

\(\frac{z_1}{z_2}=\frac{a+bi}{c+di}=\frac{(a+bi)(c-di)}{(c+di)(c-di)}=\frac{ac+bd}{c^2+d^2}+\frac{bc-ad}{c^2+d^2}i\)

Mòdul d’un nombre complex

\(z=a+bi \rightarrow |z|=\sqrt{a^2+b^2}=\sqrt{z\cdot\overline{z}}\)

Propietats:

Argument d’un nombre complex

\(z=a+bi \rightarrow \arg(z)=\) angle que forma en \(\mathbb{R^2}\) el vector origen (0,0) i final (a,b) amb el semieix \(\vec{O_x^+}\).

(Els signes d’a i b determinen el quadrant.)

Com calcular la part real i la part imaginària sabent \(|z|\) i \(\arg(z)\)?

\(\sin \alpha = \frac{b}{|z|} \rightarrow b=|z|\sin(\arg(z))\)
\(\cos \alpha = \frac{a}{|z|} \rightarrow a=|z|\cos(\arg(z))\)

Representacions dels nombres complexos

Amb \(z \in \mathbb{Z}\), la forma \(z=a+bi\) és anomenada la forma binòmica del nombre complex \(z\).

També podem expressar \(z\) per mitjà de \(|z|\) i \(\arg(z)=\alpha\) de la següent forma: \(z = |z|\cos(\arg(z)) + |z|\sin(\arg(z))i = |z|(\cos\alpha+i\sin\alpha)\). Aquesta representació s’anomena forma trigonomètrica de \(z\).

Finalment, també utilitzem la forma polar: \(z=|z|_{\arg(z)}=r_{\alpha}\) 

Representació gràfica dels nombres complexos en el pla complex:

Operacions en forma polar

Si \(r=1\), per la fórmula de la potència: \((1_\alpha)^n=1_{n\alpha}\). Desenvolupant aquesta igualtat obtenim: \((\cos\alpha + i\sin\alpha)^n = (cos(n\alpha)+i\sin(n\alpha))\), la fórmula de Moivre.

Related posts:

1. Apunts de Càlcul: Funcions d’una variable Introducció Considerem una funció real de variable real tal que...
2. Apunts d’Estructures de Dades i Algorismes: Càlcul de costs Introducció Els algorismes són per tot arreu i per això...
3. Apunts d’Estructures de Dades i Algorismes: Dividir i Vèncer Introducció L'esquema de programació de dividir i vèncer és una...

A l'hora de desenvolupar aplicacions informàtiques en grup és molt important disposar d'un sistema de control de versions (VCS, version control system). Explicat molt breument, els VCS són eines de desenvolupament que permeten desar captures del codi font (revisions) creant tot un historial de canvis a mida que avança el desenvolupament del programa; a més, permeten compartir aquestes captures amb els companys de treball i normalment tenen capacitats per resoldre conflictes entre revisions creades en para?lel per diferents persones.

Un VCS potent utilitzat correctament pot incrementar la productivitat de forma dràstica, al reduir problemes de coordinació facilitant que diferents desenvolupadors puguin compartir fàcilment les últimes versions de la seva feina i que més d'una persona pugui fer canvis simultanis a un mateix conjunt de fitxers minimitzant els possibles conflictes resultants.

Hi ha un gran ventall de sistemes de control de versions disponibles, dels quals el més conegut és segurament el Subversion. Aquest, però, permet únicament un model centralitzat i en general és bastant limitat. Personalment prefereixo sistemes com ara el Bazaar (bzr). (El Git és encara més potent, però és molt més difícil d'aprendre a utilitzar, pel qual en aquest apunt em centraré en el Bazaar; també hi ha altres alternatives, com ara el Mercurial, però no estic familiaritzat amb aquestes).

Instal·lació

En sistemes com ara l'Ubuntu o Debian està disponible en un paquet anomenat «bzr» i segurament el mateix sigui cert per a altres distribucions de GNU/Linux. Si feu servir un altre sistema operatiu podeu baixar-lo de bazaar.canonical.com.

Com a nota al marge, el Bazaar també disposa d'una interfície gràfica (Bazaar Explorer), però ja que aquest apunt l'escric orientat a desenvolupadors només explicaré el seu ús des de la línia d'ordres.

Configuració

Abans de poder fer operacions d'escriptura cal que digueu al Bazaar com us voleu identificar. Podeu fer-ho de la següent forma:

bzr whoami "Nom Cognom <email@domini.tld>"

En cas que feu servir el portal Launchpad, també podeu habilitat la integració amb aquest (si no coneixeu el Launchpad, podeu ignorar això):

bzr launchpad-login nom_usuari

Primers passos

Imaginem que estem dins un directori «el-meu-projecte» on hi tenim un seguit de fitxers de codi («main.c» i «utils.c»). Per començar a utilitzar el Bazaar amb aquest codi el primer que hem de fer és crear una branca:

bzr init

Ara podem afegir-hi els fitxers que volem que controli:

bzr add main.c utils.c

i tot seguit podem crear una primera revisió (una captura del contingut actual dels fitxers):

bzr commit -m "Primera revisió del meu nou projecte..."

Un cop fet això, imaginem que acabem de fer uns canvis al fitxer main.c. Un cop comprovat que aquests funcionen correctament, procedirem a crear una segona revisió:

bzr commit -m "Aquí aniria una descripció dels últims canvis."

I ja tenim dues revisions en la nostra branca. Ara podem recuperar el llistat de canvis que hem fet amb:

bzr log

I veuriem alguna cosa com la següents

------------------------------------------------------------
revno: 2
committer: Nom Cognom <email@domini.tld>
branch nick: foo
timestamp: Tue 2011-05-17 18:19:48 +0200
message:
  Alguns altres canvis que he fet...
------------------------------------------------------------
revno: 1
committer: Nom Cognom <email@domini.tld>
branch nick: projecte1
timestamp: Tue 2011-05-17 18:19:29 +0200
message:

  Primera revisió del meu nou projecte...

Si voleu analitzar en més detall una revisió, podeu comparar dues (o més) revisions amb l'ordre:

bzr diff -r1..2

A més, quan arribeu a una versió estable del vostre programa podeu marcar la revisió actual amb una etiqueta, fent:

bzr tag nom-etiqueta

Llavors podreu utilitzar "tag:nom-etiqueta" per referir-vos a aquella versió en lloc d'haver de consultar el número de revisió (revno).

Compartint la branca amb altres

Fins ara només hem estat treballant en local (això és possible ja que el Bazaar -al contrari de l'SVN- és un sistema distribuït). Imaginem que ara voleu compartir el codi amb un company perquè pugui ajudar amb el desenvolupament. Per això us caldrà disposar d'un servidor (qualsevol ordinador accessible, en realitat) on els dos hi tingueu accés SFTP. Enviar-hi la vostra branca completa (amb totes les revisions) és tan fàcil com:

bzr push sftp://el-meu-servidor.tld/directori/destí/projecte1

(Si més enllà de l'SFTP també teniu accés via SSH, i el servidor té el bzr insta?lat, podeu utilitzar el mode de servidor inte?ligent amb «bzr+ssh://». D'altra banda, si el company/a no té accés al servidor, sempre es pot posar la branca en un lloc accessible des de la web i llavors hi tindrà accés només de lectura, via «http://»).

Per obtenir una còpia de la branca, l'altre persona pot fer:

bzr branch sftp://nom-d'usuari@el-meu-servidor.tld/directori/destí/projecte1

A partir d'aquí, els dos podeu fer «bzr push» per enviar els vostres canvis després d'un commit i «bzr pull» per recuperar canvis nous. En cas de produir-se un conflicte (el qual es produeix si es fa un commit sense tenir les últimes revisions de la branca del servidor) es pot arreglar amb «bzr merge».

A més d'aquests constants intercanvis, en qualsevol moment un dels dos pot decidir fer un push a una nova branca (per exemple, per desenvolupar alguna nova característica experimental) i quan la feina en aquesta estigui acabada, tornar-la a integrar (amb un merge) dins la branca principal (que, per cert, normalment s'anomena trunk).

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: bzr, desenvolupament, vcs

On behalf of the Activity Log Manager team and the Zeitgeist Project, I am happy to announce the first release of Activity Log Manager (0.8.0), a user interface for managing Zeitgeist blacklists, deleting recent events as well as temporarily pausing the logging.

Grab it while it's hot. Note that you'll need Zeitgeist 0.8.0 (or later) for it to work. If you're an Ubuntu user you can get packages from our PPA; I've also uploaded it to Debian.

I'd also like to use this chance to thank Collabora for sponsoring my (and Seif's) work on Zeitgeist!

Related posts:

1. Zeitgeist 0.5.1 released! On behalf of the Zeitgeist Project team, I am pleased...
2. Zeitgeist 0.7.1 “Made in Aarhus” released! On behalf of the Zeitgeist team I am proud to...
3. GNOME Activity Journal, and installing it on Ubuntu As already announced by Seif, the first development release of...

What is Zeitgeist?

Zeitgeist is a service which logs the users's activities and events, anywhere from files opened to websites visited and conversations, and makes this information readily available for other applications to use. It is also able to establish relationships between items based on similarity and usage patterns.

The Zeitgeist engine is a user-level service and does not provide a GUI. It is intended to support dedicated journalling applications and deep integration with other desktop components.

Where?

Downloads: launchpad.net/zeitgeist/+download (zeitgeist-0.7.1.tar.gz)

About Zeitgeist: zeitgeist-project.com
Wiki: wiki.zeitgeist-project.com

See also Zeitgeist Datahub, GNOME Activity Journal and the repository for additional Zeitgeist data-sources. You may as well like Sezen.

News since 0.7.0

Engine:

 - Expose property information in the D-Bus introspection output.
 - Mention column names explicitly when inserting events, for compatibility
   with the upcoming 0.8 release.

Python API:

 - Expose DataSourceRegistry's enabled status in a callback.
 - Automatically reconnect to Zeitgeist if the connection is lost when using
   methods asynchronously (so far this only happened for synchronous calls).
 - Reinstall all active monitors upon reconnection (LP: #673008, #727226).
 - Fix a (harmless) race condition requesting the bus name (LP: #732015).

Overall:

 - Added new event interpretation types: AcceptEvent, DenyEvent and ExpireEvent.
 - Include NCO in the generated ontologies.
 - Better ./configure check for python-rdflib.
 - Update the manpage to document exit codes.

Thanks to everyone who contributed to this release, and since I hadn't blogged about it before, also to everyone who made the Zeitgeist Hackfest in Aarhus possible, including our sponsors:

Related posts:

1. Zeitgeist 0.5.1 released! On behalf of the Zeitgeist Project team, I am pleased...
2. Activity Log Manager for Zeitgeist released! On behalf of the Activity Log Manager team and the...
3. Zeitgeist 0.3.3 is out! From the release announcement: On behalf of the Zeitgeist Project...

Last Wednesday I attended the Intel AppUp Developer Day, a workshop where Intel employees presented the MeeGo stack and introduced Intel AppUp, a software center which will be shipping in netbooks/tablets/carputers/etc. There was also a live demo on how to design interfaces with QML and one of the Angry Birds creator said some words. Best of all, Intel was nice enough to give every participant a tablet!

MeeGo (really alpha!)

The ExoPC Slate came with Intel's new tablet version of MeeGo, which like its netbook counterpart seems to place great emphasis on social and multimedia uses, but it better suited for the touch screen. The system is still pre-alpha, though, and when I tried to use it lots of stuff failed to work. Asking about it at the MeeGo pavilion I was told to re-install the image, which solved some of the problems. Still, I don't really see myself using it at this point, so I decided to also put Ubuntu on it.

Installing Ubuntu

The installation went smooth; I got a message about the bootloader not being able to be installed, but I just ignored it and had no problems. I had already left half of the 64GB SSD empty when installing MeeGo, since it uses brtfs which Ubuntu can't resize yet. Of course, I had to plug in mouse and keyboard (I used a USB hub, since the tablet only has two USB ports and one is required for the installation media). Boot is somewhat slower than what I'd expect for an SSD, and sometimes shows some weird error messages which seem to have no effect.

One outstanding problem is that GRUB doesn't support the touch screen (and for that matter neither does it recognize my wireless keyboard), so if I want to change between Ubuntu and MeeGo I have to plug in a normal USB keyboard.

Getting the touch-screen to work (no multi-touch :()

The touch-screen didn't work out of the box either but required some fiddling. Basically, I had to open /etc/default/boot and change «GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"» to «GRUB_CMDLINE_LINUX_DEFAULT="quiet splash usbhid.quirks=0xeef:0x72a1:0×40"» and run «sudo update-grub», otherwise touching the screen would invariably send the pointer to the top-left. And basically, that's it, now it's working using the free drivers!

However, the free drivers only support a single finger. There's also the option of using the proprietary hid_egalax driver, which is supposed to correctly support tracking two fingers (and it does in MeeGo), but I didn't have so much luck in Ubuntu and functionally I don't really see a difference between them. To install it I downloaded the eGalaxTouch tarball: eGalaxTouch-3.04.4912-32b-k26.tar.gz. Then uncompressed the file, executed the setup script and restarted the computer. This time the result wasn't so nice, since in addition to still not doing any multi-touch, the pointer was showing up in the wrong place and somehow now the touch-screen device shows up four times. The pointer problem was easy to fix, though, by running XXXX and calibrating the four "devices", so this basically left me just how I was with the free drivers.

Since with a single finger I have no way of triggering a right-click, I enabled the "secondary click when pressing primary button" accessibility option in the mouse preferences.

Final touch (pun intended?)

For typing I've installed "matchbox-keyboard" and placed a launcher for it in the top panel. Suggestions on better alternatives are welcome (especially if they show up automatically when I focus a text box).

Now something I could do to at least get a little bit of coolness factor is enabling single-finger scroll support in Chromium, by installing the chromeTouch extension (apparently there is also a similar extension for Firefox).

Finally, I disabled the key-binding for "open music player", since by default the Slate's touch hot-key had been assigned to it and it kept opening Rhythmbox every time I accidentally went over the hot-key.

References

To wrap up this post, here's some random pages which helped me on my way here:

• eGalax Touch Screen on Ubuntu 10.04
• Ubuntu 10.10 on Gigabyte TouchNote T1028X
• Installing MeeGo and Handset Images on ExoPC
• Ubuntu on EeePC T101MT
• ExoPC does Ubuntu 10.10 Netbook
• EloTouchScreen
• Egalax-TouchScreen
• X/Testing/Touchscreen
• Bug #549447: eGalax touch-screen configured as tablet

Related posts:

1. Updated Voxforge packages in Ubuntu Just a quick note today to mention that I’ve updated...
2. Reducing SSH’s connection time on Ubuntu If you use SSH on your local network you may...
3. GNOME Activity Journal, and installing it on Ubuntu As already announced by Seif, the first development release of...

L'algorisme trivial per al càlcul dels nombres de Fibonacci repeteix molts càlculs. Podem evitar-ho desant tots els valors que calculem en una matriu i cercant-los allà quan ens calguin abans de calcular-los un altre cop (memoization). Si només ens cal obtenir un sol nombre de Fibonacci, podem construir una versió iterativa de l'algorisme que eviti els càlculs sense utilitzar espai de memòria addicional.

2. Producte encadenat de matrius

[FIXME: imatge multiplicació de matrius]. Hem vist que per multiplicar dues matrius podem utilitzar l'algorisme escolar o l'algorisme d'Strassen. Amb el primer d'ells, cal calcular \(\theta(pqr)\) productes escalars.

Si volem dur a terme una seqüència de multiplicacions, el nombre de productes escalars a fer canvia significativament segons com posem els parèntesis (el qual no té cap efecte sobre el resultat). Per exemple, amb tres matrius \(A_1 = 10×100\), \(A_2 = 100×5\) i \(A_3 = 5×50\), l'operació \((A_1 \cdot A_2) A_3\) resulta en \(10 \cdot 100 \cdot 50 + 10 \cdot 5 \cdot 50 = 7500\) productes escalars. En canvi, l'operació \(A_1 \cdot (A_2 \cdot A_3)\), amb les mateixes matrius, resultaria en \(100 \cdot 5 \cdot 50 + 10 \cdot 100 \cdot 50 = 75000\) productes escalars.

Heus aquí el problema la multiplicació encadenada de matrius: on «posar» els parèntesis per poder dur a terme les multiplicacions amb el mínim nombre de productes escalars?

Per força bruta, amb \(n\) matrius, les possibles formes de posar els parèntesis són igual al nombre d'arbres binaris amb \(n\) fulles, el qual correspon a \(C_n = \frac{1}{n + 1}{2n \choose n} \approx \frac{4^n}{3^{n/2}}\) (\(\small C\) és el nombre de Catalan). Podem definir la següent funció per trobar el nombre mínim de productes escalars per multiplicar les matrius \(A_i\), …, \(A_j\):

Aquesta operació duplica càlculs → memorització! En resulta el següent codi C++ que triga temps \(\theta(n^3)\):

vector<vector<int>> mem(n+1, vector<int>(n+1, -1));
vector<vector<int>> tall(n+1, vector<int>(n+1, -1));
 
int m(int i, int j) {
    if (mem[i][j] != -1) return mem[i][j];
    if (i == j) return 0;
    int s = MAX_INT; // infinit
    for (int k = i; k <= j; ++k) {
        int x = m(i, k) + m(k+1, j) + p[i-1] + p[k] + p[j];
        if (x < s) {
            s = x;
            tall[i][j] = k; // resposta al problema de com multiplicar-les
        }
    }
    return m[i][j] = s;
}

També podem construir-ne una versió iterativa:

for (int i = 1; i <= n; ++i) mem[i][i] = 0;
for (int i = n; i >= 1; --i) {
    for (int j = i+1; j <= n; ++j) {
        int s = MAX_INT; // infinit
        for (int k = i; k <= j; ++k) {
            int x = mem[i][k] + mem[k+1][j] + p[i-1] + p[k] + p[j];
            if (x <= s) s = x;
        }
        mem[i][j] = s;
    }
}

3. Problema de la subseqüència comuna més llarga

Tenim dues cadenes X="abcbdab" i Y="bdcaba" i volem trobar la subseqüència comuna (per exemple, "bca") més llarga (en aquest cas, la més llarga és "bdab"). Definim \(m=|X|\), \(n=|Y|\), \(X'_i\)=\(X_1\)…\(X_i\).

• Si X i Y acaben igual: l'últim caràcter d'X (o Y) ha de ser l'últim caràcter d'LCS(X, Y).
  LCS(X, Y) = \(LCS(X'_{m-1}, Y'_{n-1}) \cdot X_m\).
• Si X i Y no acaben igual, pensem què passa amb LCS(X, Y).
  \(LCS(X, Y) = \begin{cases}LCS(X_{n-1}, Y) \\ LCS(X, Y_{n-1})\end{cases}\) Quina de les dues? La més llarga.

Definim la funció \(l(i, j)\) = llargada de l'LCS(\(X'_i\), \(Y'_i\)).

Related posts:

1. Apunts d’Estructures de Dades i Algorismes: Dividir i Vèncer Introducció L'esquema de programació de dividir i vèncer és una...
2. Apunts d’Estructures de Dades i Algorismes: Càlcul de costs Introducció Els algorismes són per tot arreu i per això...
3. Apunts d’Estructures de Dades i Algorismes: Grafs Definició i propietats Graf: Graf dirigit (digraf): Un camí de...

Exemples de problemes que estan en NP:

• HAM – és difícil trobar un cicle Hamiltonià en un graf (backtracking), però donada una sentència de vèrtexs és fàcil comprovar si és una solució.
• Element mínim.
• TSP (problema del viatjant de comerç).
• Colorabilitat.
• Quadrat llatí.
• Sudoku.

Teorema

\(P \subseteq NP\)

Queda una pregunta clau: \(P = NP\)?

Reducció

Siguin \(L_1 \le E_1\) i \(L_2 \le E_2\) dos problemes decisionals. Diem que \(L_1\) es redueix a \(L_2\) en temps polinòmic si podem trobar un algorisme polinòmic \(A: L_1 \rightarrow L_2\), és a dir, que converteixi tota solució a \(E_1\) en una solució d'\(E_2\).

En altres paraules, una reducció en temps polinòmic d'\(L_1\) a \(L_2\) és un algorise \(R: E_1 \rightarrow E2 / \forall x \in E_1: x \in L1 \Leftrightarrow R(x) \in L_2\).

Podem reduir, per exemple, el problema del graf hamiltonià (HAM) al problema del viatjant de comerç (TSP).

Teorema: Si \(L_1 \le_p L_2\) i \(L_2 \in P\), llavors \(L_1 \in P\).

Un problema decisional \(L\) és NP-hard si tot problema en NP es pot reduir a ell en temps polinòmic. \(L \in \text{NP-hard} \Leftrightarrow \forall L' \in NP, L' \le_p L\).

Un problema és NP-complet si és NP-hard i es troba en NP.

Teorema:
\(L \in NP-hard, L \in P \Leftrightarrow P = NP\).

Teorema:
\(\left\{\begin{array}{l}L_1 \in \text{NP-C} \\ L_2 \in NP \\ L_1 \hookrightarrow L_2\end{array}\right\} L_2 \in NP-C\)

Teorema de Cook (~1970)
\(\small\text{CIRCUIT-SAT} \normalsize\in \small\text{NP-C}\) (va ser el primer problema NP-complet).

El problema decisional CIRCUIT-SAT pren com a entrada un circuit amb \(n\) entrades booleanes, una sortida i portes AND, OR i NOT i el que pregunta és, «hi ha alguna entrada del circuit que faci que la sortida sigui 1?».

Nota: Una possible solució donada per justificar que un problema decisional té solució s'anomena testimoni.

Solucions pràctiques per a problemes NP

• Heurístiques.
• Aproximacions.
• Paral·lelisme, ordinadors quàntics…

El problema de l'aturada

A part de les classes de problemes P, NP i NP-C n'hi ha moltes d'altres, i una d'elles que cal mencionar és la dels problemes irresolubles: aquells que l'ordinador (o millor dit, una màquina de Turing) no pot solucionar.

Un exemple de problema irresoluble és el de l'aturada: donada la descripció d'un programa i el seu estat inicial, determinar si el programa, si l'executem, arribarà a completar-se o bé funcionarà fins la fi de l'eternitat. Podem veure-ho amb el següent programa d'exemple:

typedef String Programa;
typedef String Entrada;
 
// Funció que retorna cert si el programa p, donada l'entrada
// x, arriba a aturar-se
bool acaba(Programa p, Entrada x);
 
void vinga(Programa p) {
    // Entra en un bucle infinit si el programa p, donant-li com a entrada
    // el mateix codi del programa, arriba a aturar-se
    if (acaba(p, p)) while (true);
}

Si analitzem aquest programa i executem vinga(vinga) veiem que pot haver-hi dos casos:

1. Que acabi – si acaba, vinga entra en el bucle i no acaba → contradicció.
2. Que no acabi – si no acaba, vinga acaba → contradicció.

Així doncs, no es pot solucionar el problema de l'aturada.

Related posts:

1. Apunts d’Estructures de Dades i Algorismes: Cerca exhaustiva Cerca exhaustiva La cerca exhaustiva és un mètode de disseny...
2. Apunts d’Estructures de Dades i Algorismes: Dividir i Vèncer Introducció L'esquema de programació de dividir i vèncer és una...
3. Apunts d’Estructures de Dades i Algorismes: Grafs Definició i propietats Graf: Graf dirigit (digraf): Un camí de...

La cerca exhaustiva és un mètode de disseny d'algorismes que consisteix en mirar-se sistemàtica i intel·ligentment totes les possibles solucions a un problema donat.

Generalment els problemes que es resolen mitjançant aquesta tècnica són problemes d'optimització o combinatoris.

La tècnica consisteix en generar implícitament un arbre representant totes les possibles solucions i explorar-lo en profunditat, deixant de recórrer aquelles branques que corresponguin a «candidats a solució» que no compleixen les restriccions del problema donat. Nosaltres la veurem per backtracking.

Exemple. El problema de les «n» reines

Donat un tauler d'\(n\)x\(n\) caselles i \(n\) reines, cal situar-les de manera que no s'amenacin entre elles (segons les regles dels escacs). Vés aquí algunes opcions:

1. Podem mirar totes les possibles configuracions i veure quines compleixen les restriccions del problema. Això són \(n^2 \choose n\) combinacions; amb \(n=8\) això són \({64 \choose 8} = 4426165368\) possibilitats.
2. Podem limitar-nos a posar una única reina en cada línia. Això són \(n^n\) possibilitats; amb \(n=8\), \(8^8 = 16777216\).
3. Podem posar una única reina en cada fila i columna. Això són \(n!\) possibilitats; amb \(n=8\), \(8! = 40320\).
4. Podem posar una única reina en cada fila, columna i diagonal.

El problema amb aquestes propostes és que fins que no hem acabat de construir una configuració no es mira si les condicions es compleixen o no. Ja en podríem desestimar moltes mentre s'estan construint: utilitzem la tècnica del backtracking.

Una part important d'aquesta tècnica consisteix en determinar una manera per a representar les possibles configuracions (solucions) del problema. En el cas de les reines, ho farem amb una taula d'\(n\) posicions, tal que \(v[i]\) és la columna on va la reina i que al tauler anirà en \((i, v[i])\).

Definim un vector \(k\)-completable de la següent manera: sigui \((k-1)\)-completable, i \(\forall i\ tal\ que\ 1 \le i \le k-1, v[i] \ne v[k], i + v[i] \ne k + v[k], n – v[i] + i \ne n – v[k] + k\). Les solucions al problema de les \(n\) reines són els vector \(n\)-completables.

Observacions:

1. \(i \ne j, \forall 1 \le i, j \le k, v[i] \ne v[j], v[i] + i \ne v[j] + j,\) \(n – 1 – v[i] + i \ne n – 1 – v[j] + j\) (les dues darrers condicions cobreixen les diagonals).
2. El vector ha de ser \((k – 1)\)-completable i, a més, \(\forall 1 \le i \le k – 1, v[i] \ne v[k], v[i] + i \ne v[k] + k, n – 1 – v[i] + i \ne n -1 – v[k] + k\).
3. Tots els vectors són \(1\)-completables.
4. Les solucions al problema són els vectors n-completables.

Exemple. El problema de la motxilla

«Una motxilla té lloc per a C unitats de pes. Tria d'entre \(n\) objectes amb pesos \(p[i], …, p[n]\) i valor \(v[i], …, v[n]\) la combinació d'objectes amb pes total inferior a C amb el valor màxim».

Related posts:

1. Apunts d’Estructures de Dades i Algorismes: Les classes de problemes P i NP Classes de problemes – P i NP Entrades Problemes Classes...
2. Apunts d’Estructures de Dades i Algorismes: Dividir i Vèncer Introducció L'esquema de programació de dividir i vèncer és una...
3. Apunts d’Estructures de Dades i Algorismes: Programació dinàmica 1. Nombres de Fibonacci L'algorisme trivial per al càlcul dels...

Graf:
\(\begin{array}{lll}G: & \small V\grave{e}rtexs/Nodes & V = \{1, 2, 3, 4\} \\ & \small Arestes & E = \left\{\{1, 2\}, \{1, 3\}, \{2, 3\}, \{3, 4\}\right\}\end{array}\)

Graf dirigit (digraf):
\(\begin{array}{lll}G': & \small V\grave{e}rtexs/Nodes & V = \{1, 2, 3, 4\} \\ & \small Arcs & E \subset VxV\ \small (un\ arc\ \acute{e}s\ un\ parell\ ordenat\ de\ v\grave{e}rtexs)\\ & & E = \left\{(1, 2), (1, 3), (2, 3), (3, 4)\right\}\end{array}\)

Un camí de longitud \(l\) és una seqüència de vèrtexs connectats (per arrestes/arcs) entre ells. Si tots els vèrtexs són diferents, el camí és simple. Un cicle és un camí simple amb la peculiaritat que comença i acaba al mateix vèrtex.

El diàmetre d'un graf és el màxim de tots els camins mínims.

Diem que un graf \(G = (V, E)\) és connex si per tot parell de vèrtexs \(u, v \in V\) existeix un camí que comença en \(u\) i acaba en \(v\).

Un graf no dirigit, connex i acíclic (sense cicles) és un arbre (arbre lliure); és un graf no dirigit on hi ha exactament un camí entre cada parell de vèrtexs. Els arbres tenen les següents propietats:

• un arbre amb \(n\) vèrtex té \(n – 1\) arestes;
• si s'afegeix una aresta a un arbre llavors tindrà un (únic) cicle;
• si s'elimina una aresta d'un arbre llavors deixa de ser connex.

Un graf dirigit és fortament connex si tots els parells de vèrtexs (considerant l'ordre) tenen un camí que els uneix, i dèbilment connex si és connex al convertir-lo en un graf no dirigit.

Un vèrtex \(v\) és adjacent al vèrtex \(u\) si \(\{u, v\} \in E\) (\((u, v) \in E\) si és un graf dirigit).

El grau d'un vèrtex és el nombre de vèrtexs adjacents a ell i el grau d'un graf és el grau màxim dels vèrtexs.

En grafs no dirigits, \(G = (V, E)\), es compleix el següent teorema: \(\sum_{u \in v}grau(u) = 2|E|\).

Un graf és complet si conté el màxim nombre d'arestes/arcs possible. En el cas d'un graf aquest és \(\frac{n(n-1)}{2}\) i en el cas d'un graf dirigit \(n(n-1)\).

Un graf connex i no dirigit és Eulerià si i només si existeix un camí que inclou cada aresta del graf exactament un cop.

Un graf és Hamiltonià si i només si conté un cicle Hamiltonià (un cicle simple de longitud \(|V|\)).

Un graf és planar si és possible representar-lo en paper sense que es creui cap línia. El teorema de Kuratowski afirma que només el grafs que no contenen \(k_{3,3}\) (el graf complet bipartit de 6 vèrtexs) ni \(K_5\) (el graf complet de 5 vèrtexs) són planars. Enllaç: article a la Viquipèdia.

Els grafs també poden tenir les següents característiques, que no utilitzarem en aquest curs:

• Bucle (loop): aresta/arc que comença i acaba en el mateix vèrtex.
• Multigrafs: graf amb més d'una aresta/arc connectant el mateix parell de vèrtexs.

Implementació

El tipus abstracte de dades (TAD) graf compta amb mètodes com crea, inserta_aresta, compta_vertex, etc. Les dades es poden representar de diverses maneres.

Matriu d'ajdacència

Consisteix en representar el graf en una matriu de booleans \(n x n\). Per a grafs no dirigits i sense bucles, és una matriu triangular, simètrica en els dos costats.

… [FIXME: aquí van dues imatges d'exemple i les matrius corresponents] …

• Espai: \(\theta(n^2)\)
• Temps de creació: \(\Omega(n^2)\) (\(\theta(n^2)\) més el temps de lectura del graf)

Llista d'adjacència

typedef vector<list<int>> graf;
// o millor:
typedef vector<vector<int>> graf;

• Espai: \(\theta(n + m)\) on \(n\) és el nombre de vèrtex i \(m\) el nombre d'arestes.

Quina de les representacions és més convenient?

La matriu és més eficient en temps (accès directe a qualsevol posició en \(\theta(1)\)) però en espai pot ser molt ineficient (quan conté molts zeros, en el cas de grafs esparsos). Utilitzem la matriu per a grafs densos (\(|E| = \theta(n^2)\)).

Exemple

Tenim un graf amb \(n = 4182\) vèrtex i \(m = 12384\) arestes.

L'espai en memòria que aquest ocuparà en cas d'utilitzar una matriu d'adjacència, suposant que un booleà ocupa un byte, és \(\frac{4182^2}{2} \simeq 8.34MB\) (suposant que un booleà ocupa un bit, serien \(\frac{4182^2}{2 \cdot 8} = 1.04MB\)).

Si en lloc d'una matriu utilitzem una llista d'adjacència, on cada enter (o punter) ocupa 4 bytes, l'espai que ocuparà és \(4182 \cdot 4 + 12384 \cdot 4 \cdot 2 = 0.11MB\) (multipliquem per 2 al suposar que es tracta d'un graf no dirigit).

Recorreguts

Un recorregut és una manera sistemàtica de visitar tots els vèrtex d'un graf.

Recorregut en profunditat

El recorregut en profunditat (DFS, depth first search), similar al recorregut en pre-ordre dels arbres, consisteix en visitar un vèrtex i continuar el recorregut amb un vèrtex adjacent o l'últim vèrtex visitat que no hagi estat visitat fins ara.

list<int> dfs(const graf& G) {
    list<int> L;
    vector<bool> visitat(G.size(), false);
    stack<int> S;
    for (int i = 0; i < G.size(); ++i) {
        if (not visitat[i]) {
            S.push(i);
            while (not S.empty()) {
                int v = S.top(); S.pop();
                L.push_back(v); visitat[v] = true;
                for (int w = 0; w < G[v].size(); ++w) {
                    if (not visitat[G[v][w]]) S.push(G[v][w]);
                }
            }
        }
    }
    return L;
}

Recorregut en amplada

El recorregut en amplada (BFS, breadth first search) és similar al recorregut per nivells en un arbre. La implementació és similar a la del recorregut en profunditat, però utilitzant una cua en lloc d'una pila.

list<int> bfs(const graf& G) {
    list<int> L;
    vector<bool> encuat(G.size(), false);
    queue<int> Q;
    for (int i = 0; i < G.size(); ++i) {
        if (not encuat[i]) {
            Q.push(i); encuat[i] = true;
            while (not Q.empty()) {
                int v = Q.front(); Q.pop();
                L.push_back(v);
                for (int w = 0; w < G[v].size(); ++w) {
                    if (not encuat[G[v][w]]) {
                        Q.push(G[v][w]); encuat[G[v][w]] = true;
                    }
                }
            }
        }
    }
    return L;
}

Ordenació topològica

Donat un graf dirigit i acíclic (DAG, directed acyclic graph), \(G = \{V, E\}\), una ordenació topològica de \(G\) és una ordenació dels seus vèrtexs tal que per tot parell de vèrtexs \(u, v \in V\), si existeix un camí d'\(u\) a \(v\) al graf \(G\), aleshores \(v\) no pot aparèixer abans que \(u\) a l'ordenació.

Algorisme: Calculem el grau d'entrada (el número d'arcs entrants) de tots els nodes. Afegim aquells on el grau és zero en una pila i restem 1 al grau de tots els seus nodes adjacents; aquells adjacents que passin a grau 0 també els afegim a la pila.

Com podem veure, l'ordenació topològica és una aplicació del recorregut en profunditat. També és evident que no és única, ja que pot tenir molts resultats possibles:

Algorisme de Dijkstra

Un graf \(G = \{V, E\}\) és un graf amb pesos (weighted graph) si cada aresta \(\{u, v\}\) (o arc \((u, v)\)) del graf té associat un valor \(w \in \mathbb{R}\). Si \(w \in \mathbb{R}^{+}\), \(G\) és un graf amb pesos positius; si \(w \in \mathbb{R}^{+} \cup \{0\}\), és un graf amb pesos no negatius.

Donat un graf \(G\) amb pesos, el pes (també anomenat valor, cost o distància, si els pesos són positius) és la suma dels pesos de les arestes (o arcs) del camí.

Donats dos vèrtexs \(u, v \in V\) qualssevol, diem que un camí d'\(u\) a \(v\) és mínim (o de pes mínim) si el seu pes és més petit o igual que el pes de qualsevol altre camí d'\(u\) a \(v\). (Si no hi ha cap cami d'\(u\) a \(v\) diem, per definició, que el pes és \(\infty\)).

L'algorisme de Dijkstra (pronunciació: 'd3Ikstra) calcula els camins mínims d'un vèrtexs \(v\) cap a tots els altres vèrtexs del graf. Es tracta d'un algorisme voraç (greedy).

… [FIXME: aquí va un exemple] …

Observacions:

• L'algorisme de Dijkstra no funciona si hi ha pesos negatius.
• El seu cost és \(O(n^2)\).

Anàlisi de costs

Cost del recorregut en amplada

1. Cada vèrtex del graf entra i surt de la cua exactament una vegada. Això correspon a un temps \(\theta(|V|)\).
2. La llista d'adjacències de cada vèrtex es recorre una única vegada, en el moment de treure el vèrtex de la cua. Per tant, per cada vèrtex \(u\) això correspon a un temps \(\theta(Adj(u))\), i en total, per a tots els vèrtexs, això correspon a un temps \(\theta(\sum_{u \in V}Adj(u)) = O(|E|)\).
3. Hi ha el cost de les inicialitzacions, que és \(O(n)\).

En total, el cost del recorregut en amplada és \(O(n + m) = O(|V| + |E|)\).

Cost del recorregut en profunditat

1. El bucle exterior es fa \(\theta(|V|)\) vegades.
2. Per cada iteració, el bucle interior es fa per tots els adjacents a cada vèrtex amb un cost \(\theta(1)\). En total, el cost és \(\theta(|E|)\).
3. El cost de les inicialitzacions és \(O(n)\).

En total, el cost del recorregut en profunditat és \(\theta(|V| + |E|)\).

Cost de l'ordenació topològica

És igual al cost del recorregut en profunditat.

Cost de l'algorisme de Dijkstra

• Sense fer servir cues de prioritat:
  Per a cada vèrtex que s'afegeix al conjunt solució el cost en temps és \(O(n)\) en cas pitjor. Com que s'hi han d'afegir els \(n\) vèrtexs del grup, en total el cost és \(O(n^2)\).
• Fent servir cues de prioritat per guardar les arestes/arcs:
  A cada pas afegim un nou element al conjunt solució, tret de la cua de prioritats, amb cost \(log n + (log n) Adj(v)\). En total: \(O((n + m) log n)\).

Enllaços rellevants

• ADA: Algorismes sobre grafs, per Gabriel Valiente.
• Article sobre grafs a la Viquipèdia.

Related posts:

1. Apunts d’Estructures de Dades i Algorismes: Càlcul de costs Introducció Els algorismes són per tot arreu i per això...
2. Apunts d’Estructures de Dades i Algorismes: Diccionaris Introducció Són un tipus abstracte de dades (TAD), és a...
3. Apunts d’Estructures de Dades i Algorismes: Dividir i Vèncer Introducció L'esquema de programació de dividir i vèncer és una...

Són un tipus abstracte de dades (TAD), és a dir, un conjunt d'elements i un conjunt d'operacions sobre ells.

Un diccionari és un conjunt d'elements amb una clau associada (treta d'un conjunt amb un ordre total definit) amb les operacions de cercar, inserir i esborrar un element.

Una estructura de dades és una estructura que ens permet implementar TAD.

Implementacions de diccionaris

1) Taules (no ordenades)

• Inserir un element nou: \(\theta(1)\).
• Esborrar un element: cost de cercar l'element (\(O(n)\)) + cost de treure'l de la taula (varia segons el mecanisme d'eliminació, possiblement \(O(n)\)).

2) Llistes (enllaçades, encadenades)

Per recórrer una llista s'ha de fer de forma seqüencial, mitjançant iteradors (punters).

• Inserir un element nou:
    - al principi: \(\theta(1)\);
    - al final de la llista, recorrent-la sencera: \(\theta(n)\).
• Cercar un element: \(O(n)\)
• Esborrar un element: \(O(n)\)

3) Taules de dispersió (hash tables)

El disseny de la funció de hash és molt important per obtenir taules ben equilibrades.

En cas pitjor, el cost serà de \(\theta(n)\), inserint al final amb una funció de dispersió que resulti en llistes llargues. Però, si la funció de dispersió està ben dissenyada, repartirà els elements equitativament, resultant llistes de mitjana \(\alpha = \frac{n}{M}\) amb un cost \(\theta(\alpha)\).

4) Arbres binaris de cerca (ABC, o Binary Search Tree, BST)

Un ABC és un arbre binari on cada node té una clau associada i els sub-arbres esquerra i dret compleixen les següents propietats:

1. \(\forall\) clau \(y\) associada a un node del sub-arbre esquerra d'un node amb clau \(x\) es compleix que \(y < x\).
2. \(\forall\) clau \(y\) associada a un node del sub-arbre dret d'un node amb clau \(x\) es compleix que \(y > x\).

Observacions:

1. Suposem que totes les claus són diferents.
2. Un arbre buit és per definició un ABC.

• Construir un ABC a partir d'un arbre buit i un conjunt d'\(n\) claus:
    - cas millor: \(\theta(n log n)\) (arbre equilibrat);
    - cas mitjà: \(\theta(n log n)\), suposant que totes les permutacions de les \(n\) claus són igualment probables;
    - cas pitjor: \(\theta(n^2)\) (ordenats).
• Inserir una clau en un arbre d'\(n\) nodes: \(\theta(h)\), on \(h\) és l'alçada de l'arbre.
  \(h = \begin{cases}n & \small en\ cas\ pitjor \\ log n & \small en\ el\ cas\ millor\ i\ mitj\grave{a}\end{cases}\)
• Cercar una clau en un arbre d'alçada \(h\): \(\theta(h)\).
• Esborrar:
   - Esborrar el 9: esborrar un fulla; és fàcil.
   - Esborrar el 7: esborrar un node amb un sub-arbre buit, és fàcil.
   - Esborrar l'11: cal substituir-lo pel mínim del sub-arbre dret (o bé pel màxim del sub-arbre esquerra).

   

Arbres AVL (Adel'son-Vel'skîi-Landis)

Un arbre AVL és un arbre binari de cerca tal que per tot node l'alçada del seu seu-arbre esquerre no difereix en més d'una unitat que l'alçada del seu sub-arbre dret.

• Cercar una clau: algorisme idèntic al dels ABC i de cost \(O(log n)\).
• Inserir una clau: es fa servir el mateix algorisme dels ABC i desprès, si la propietat de les alçades ja no és certa, es reestructura l'arbre per tal que torni a ser un arbre AVL.
  Per tal de dur a terme la reestructuració, cada node ha de contenir informació de la seva alçada. A més, definim el concepte de factor d'equilibri, com a l'alçada del sub-arbre esquerra menys l'alçada del sub-arbre dret; per ser \({-1, 0, 1}\). Al fer una inserció, el primer node en tenir un mal factor d'equilibri (és a dir, de valor absolut superior a 1) és el node crític i és on caldrà fer una rotació. Podem trobar-nos amb quatre casos:
  • Inserció al sub-node esquerre del sub-node esquerre del node crític (cas LL, left-left): cal fer una rotació simple.
  • Inserció al sub-node dret del sub-node esquerre del node crític (cas LR): cal fer una rotació doble.
  • Inserció al sub-node esquerre del sub-node dret del node crític (cas RL): cal fer una rotació doble.
  • Inserció al sub-node dret del sub-node dret del node crític (cas RR): cal fer una rotació doble.

  El cost d'una inserció és \(\theta(h)\) (on h és l'alçada de l'abre, \(h = \theta(log n)\)) i el d'una rotació és \(\theta(1)\).

• Esborrar una clau: poden caldre fins a \(log n\) passos per a rebalancejar l'arbre.

Cues de prioritat

Es creen en temps \(O(n)\) amb l'algorisme heapify; són un arbre que compleix la propietat que la clau de tot node és inferior o igual a la clau del node pare.

• Crear una cua de prioritats: \(O(n)\).
• Consultar-ne el valor mínim o màxim: \(\theta(1)\).
• Esborrar-ne el valor mínim o màxim: \(\theta(log n)\).
• Inserir un element: \(O(log n)\).

Tipus abstractes de dades de la llibreria estàndard de C++

Related posts:

1. Apunts d’Estructures de Dades i Algorismes: Grafs Definició i propietats Graf: Graf dirigit (digraf): Un camí de...
2. Apunts d’Estructures de Dades i Algorismes: Dividir i Vèncer Introducció L'esquema de programació de dividir i vèncer és una...
3. Apunts d’Estructures de Dades i Algorismes: Càlcul de costs Introducció Els algorismes són per tot arreu i per això...

L'esquema de programació de dividir i vèncer és una tècnica per a resoldre problemes que consisteix en dividir el problema original en subproblemes (més petits), resoldre els subproblemes i finalment combinar les solucions en una sola que resolgui el problema original. Mitjançant aquest tècnica sovint obtenim una solució recursiva.

Exemples

1. Cerca dicotòmica: \(T(n) = O(log n)\)
2. Exponenciació ràpida: \(T(n) = \theta(log n)\)
   \(x^n = \begin{cases}1 & n = 0 \\ (x^2)^{\frac{n}{2}} & n \gt 0, n\ \acute{e}s\ parell \\ x \cdot (x^2)^{\left\lfloor \frac{n}{2} \right\rfloor} & n \gt 0, n\ \acute{e}s\ senar\end{cases}\)
3. Merge sort: \(T(n) = \theta(n log n)\)
4. Quick sort (inventat el 1960 per Hoare): \(T(n) = \begin{cases}\small cas\ millor: & 2T(\frac{n}{2}) + \theta(n) & \rightarrow \theta(n log n) \\ \small cas\ mitj\grave{a}: & \frac{1}{n}\sum_{i=1}^{n}T(i) + T(n-i) + \theta(n) & \Rightarrow \theta(n log n) \\ \small cas\ pitjor: & c + T(n – 1) + \theta(n) & \Rightarrow \theta(n^2)\end{cases}\)

   Consististeix en agafar un pivot \(x\) i dividir l'entrada en aquells elements \(\le x\) i aquells \(\ge x\), i repetir aquest procediment de forma recursiva en els dos grups. En la definició de \(T(n)\), \(i\) representa el nombre d'elements \(\le x\) i depèn del pivot.

   

   Nota: La llibreria estàndard de C++ disposa d'una implementació de l'algorisme Introsort, que ordena amb quick sort però compta el nombre de crides recursives. A partir d'un cert nombre \(c_{2} \cdot log n\) canvia a heap sort.

5. Quick Select (selecció del \(k\)-èssim element d'una taula desordenada) \(T(n) = \begin{cases}\small cas\ millor\ i\ mitj\grave{a}: & s(n) = s(\frac{n}{2}) + \theta(n) & \Rightarrow \theta(n) \\ \small cas\ pitjor: & s(n) = s(n – 1) + \theta(n) & \Rightarrow \theta(n^2)\end{cases}\)

   Consisteix en agafar un pivot \(x\), fer la partició i trobar la posició \(q\) de l'element de més a la dreta del primer grup. Si \(q = k\) llavors ja hem acabat (el \(k\)-èssim és l'element \(T[q]\)); si \(q \lt k\) cerquem l'element \(k – q\) al segon grup; finalment, si \(q \gt k\), cerquem l'element \(k\)-èssim a T1.

   Nota: existeix un altre algorisme de selecció en temps lineal en el cas pitjor: Floyd-Wilson.

6. Algorisme de Karasuba (per a multiplicar)

   L'algorisme per a multiplicar clàssic du a terme \(O(n^2)\) operacions. L'algorisme de Karatsuba és més ràpid per a nombres molt grans.

   Sense pèrdua de generalitat: suposem nombres binaris, de la mateixa longitud i sent aquesta longitud una potència de 2. Per exemple, x = [a|b], y = [c|d].
   \((a \cdot 2^{\frac{n}{2}} + b) (c \cdot 2^{\frac{n}{2}} + d) = x \cdot y\)
   \(u = (a+b) (c+d)\ \ \ \ v = a \cdot c\ \ \ \ w = b \cdot d\)
   \(x \cdot y = v \cdot 2^n + (u – v – w) \cdot 2^(\frac{n}{2}) + w\)

   \(T(n) = 3T(\frac{n}{2}) + \theta(n) \Rightarrow T(n) = \theta(n^{log_{2}3 \simeq 1.585})\)

Alguns apunts addicionals:

• El merge sort (implementat correctament) és un algorisme d'ordenació estable, amb el quick sort aquest no és el cas.
• L'algorisme quick sort cau en el seu temps pitjor quan l'entrada ja està ordenada.

Implementació del quick sort

int partició<vector<elem>& v, int e, int d) {
    // Hoare
    Elem x = v[e];
    int i = e - 1;
    int j = d + 1;
    while (true) {
        while (v[--j] > x);
        while (v[++i] < x);
        if (i >= j) return j;
        swap (v[i], v[j]);
    }
}
void quicksort(vector<elem>& v, int e, int d) {
    if (e < d) {
        int p = partició(v, e, d);
        quicksort(v, e, p);
        quicksort(v, p+1, e);
    }
}

Enllaços rellevants

• Esquema de Dividir y Vencer, Amalia Duch.
• Merge sort i Quick sort, Wikipedia.
• Explicació i exemple interactiu del QuickSelect.

Related posts:

1. Apunts d’Estructures de Dades i Algorismes: Càlcul de costs Introducció Els algorismes són per tot arreu i per això...
2. Apunts d’Estructures de Dades i Algorismes: Programació dinàmica 1. Nombres de Fibonacci L'algorisme trivial per al càlcul dels...
3. Apunts d’Estructures de Dades i Algorismes: Diccionaris Introducció Són un tipus abstracte de dades (TAD), és a...

Els algorismes són per tot arreu i per això volem analitzar-ne les característiques. Algunes de les característiques més importants dels algorismes són:

• correctesa!
• senzillesa
• escalabilitat
• modularitat
• eficiència
• fiabilitat
• etc.

Nosaltres en concret en mirarem l'eficiència i l'ús dels recursos del sistema a nivell teòric, és a dir, el temps d'execució, la quantitat de memòria que utilitzen, etc.

Suposarem que el cost de totes les operacions elementals és constant, i anomenem «n» la mida de l'entrada, en funció de la qual veurem el cost en temps i memòria dels algorismes.

Def. Donat un algorisme A, amb conjunt d'entrades \(\vartheta\), el seu cost (eficiència) és una funció: \(\begin{array}{ll}T: & \vartheta \rightarrow \mathbb{R}^{+} \\ & \alpha \mapsto T(\alpha)\end{array}\)

Per facilitar la manipulació de cost restringim el conjunt \(\vartheta\) al conjunt \(\vartheta_{n}\), que correspon al de totes les entrades de mida \(n \in \mathbb{R}\).

Def. Donat un algorisme A, amb un conjunt d'entrades de mida n (\(\vartheta_{n}\)), el cost d'A en el cas millor, pijtor i mitjà és:

• \(T_{millor}(n) = min\left\{T_{n}(\alpha) | \alpha \in \vartheta_{n}\right\}\)
• \(T_{pitjor}(n) = max\left\{T_{n}(\alpha) | \alpha \in \vartheta_{n}\right\}\)
• \(T_{mitj\grave{a}}(n) = \sum_{\alpha \in \vartheta_{n}} Pr(\alpha) \cdot T_{n}(\alpha)\)
  (suposant un coneixement de la distribució estadística de les entrades)

Observacions:

• \(T_{millor}(n) \le T_{n}(\alpha) \le T_{pitjor}(n)\)
• \(T_{millor}(n) \le T_{mitj\grave{a}}(n) \le T_{pitjor}(n)\)

Notació asimptòtica

Considerem funcions del tipus \(f: \mathbb{N} \rightarrow \mathbb{N}\). Definim:

• \(O(f) = \left\{g: \mathbb{N} \rightarrow \mathbb{N}, \exists n_0 \ge 0, \forall n \ge n_{0}: g(n) \le f(n) \cdot c_{0}\right\}\) \(g \in O(f) \Leftrightarrow\) «\(g\) creix més a poc a poc o igual que \(f\)» (per a valors prou grans i ignorant les pendents)

• \(\Omega(f) = \left\{g: \mathbb{N} \rightarrow \mathbb{N}, \exists n_0 \ge 0, \forall n \ge n_{0}: g(n) \ge f(n) \cdot c_{0}\right\}\) \(g \in \Omega(f) \Leftrightarrow\) «\(g\) creix més ràpid o igual que \(f\)»

• \(\theta(f) = O(f) \cap \Omega(f)\) \(g \in \Omega(f) \Leftrightarrow\) «\(g\) creix igual que \(f\)» (en altres paraules, \(g\) i \(f\) tenen el mateix ordre de creixement)

Considerant \(g: \mathbb{N} \rightarrow \mathbb{R}^{+}\) les definicions serien similars.

Propietats

• • \(\lim_{n \to \infty} \frac{f(n)}{g(n)} \lt +\infty \Rightarrow f \in O(g)\)
  • \(\lim_{n \to 0} \frac{f(n)}{g(n)} \gt 0 \Rightarrow f \in \Omega(g)\)
  • \(\lim_{n \to \infty} \frac{f(n)}{g(n)} \in (0, \infty) \Rightarrow f \in \theta(g)\)
  • Nota: Regla de L'Hôpital.
• Reflexivitat: \(f \in O(f)\) (ídem per a \(\Omega\) i \(\theta\))
• Transitivitat: \(f \in O(g) \land g \in O(h) \Rightarrow f \in O(h)\) (semblant per a \(\Omega\) i \(\theta\))
• Regles de càlcul:
  • \(O(f) = O(f \cdot c) \forall c \gt 0 ct.\)
  • \(O(f) + O(g) = O(f + g) = O\left(m\grave{a}x\{f, g\}\right)\)
  • \(O(f) \cdot O(g) = O(f \cdot g)\)
  • (ídem per a \(\Omega\) i \(\theta\))

Convenció

Per convenció es fa un abús del llenguatge i sovint escrivim \(f = O(g)\) quan realment volem dir \(f \in O(g)\). (Cal tenir en compte això a l'utilitzar la propietat de transitivitat!) Per exemple:

• \(4n = O(n^2) = O(n^3)\) on realment hauria de ser \(\subseteq\)
• \(2n = O(n)\)

Funcions de cost

En general, tenim un algorisme \(A\) amb un conjunt d'entrades \(E\). Volem caracteritzar l'ús d'algun recurs quan s'executa \(A\) sobre una entrada \(x \in E\).

Obtenir \(C_{A}(x)\) és, en general, massa difícil \(\Rightarrow\) simplifiquem. No mirem cada entrada individual sinó que ajuntem totes les entrades de la mateixa talla. Anomenem \(|x|\) la talla d'\(x\).

Estudiem els algorismes calculant el seu cost en funció de la talla de les seves entrades. A més, només mirarem els costos pitjor i millor (veure introducció) i \(C_{mitj\grave{a}}(n) = \frac{1}{|E_{n}|} \sum_{x \in E_{n}} C_{A}(x)\) on \(E_{n} = \left\{x \in E \mid |x|= n\right\}\) (aquesta darrera funció de cost és difícil d'obtenir i no té en compte les probabilitats).

Així doncs, en algorísmica calculem els costos dels algorismes donant fites (superiors i inferiors) en funció de la talla de les entrades, utilitzant notació asimptòtica.

Cost d'algorismes recursius

El cost dels algorismes recursius s'expressa generalment mitjançant una equació recorrent (recurrència). El cost de l'algorisme ve donat per la solució a aquesta. Dos tipus de recurrències freqüents són les recurrències substractores i les recurrències divisores.

Recurrències substractores

Les recurrències substractores prenen la forma següent:

On \(a\) és una constant no negativa (\(a \ge 0\)), \(c\) és una constant estrictament positiva (\(c \ \)) i \(g\) és una funció amb cost \(\theta(n^k)\).

Teorema mestre I (per a recurrències substractores)

Donada la recurrència anterior, trobem el cost segons: \(T(n) = \begin{cases}\theta(n^k) & a < 1 \\ \theta(n^{k+1}) & a = 1 \\ \theta(a^{n/c}) & a > 1\end{cases}\)

Recurrències divisores

Les recurrències divisores prenen la següent forma:

On \(a\) és una constant no negativa (\(a \ge 0\)), \(b > 1\) i \(g\) és una funció amb cost \(\theta(n^k)\).

Teorema mestre II (per a recurrències divisores)

Sigui \(\alpha = log_{b}(a)\), i donada la recurrència anterior, aleshores: \(T(n) = \begin{cases}\theta(n^k) & \alpha < k \\ \theta(n^{\alpha} \cdot log n) & \alpha = k \\ \theta(n^{\alpha}) & \alpha > k\end{cases}\)

Related posts:

1. Apunts d’Estructures de Dades i Algorismes: Dividir i Vèncer Introducció L'esquema de programació de dividir i vèncer és una...
2. Apunts d’Estructures de Dades i Algorismes: Diccionaris Introducció Són un tipus abstracte de dades (TAD), és a...
3. Apunts d’Estructures de Dades i Algorismes: Grafs Definició i propietats Graf: Graf dirigit (digraf): Un camí de...

I’ve also decided to only include commercial games in this post; if it gets positive feedback I may also post a list of my favourite free games.

Anyway, here it goes:

	Vendetta Online A massively multiplayer online first-person space-combat game featuring possibilities in trading, mining, combat, warfare, piracy… Price: $9.99 / month (free 8 hour trial) License: Proprietary
Lugaru HD A third-person action game featuring a rabbit on a fight to save his fellow rabbits from slavery in a fight against corrupt rabbits and wolves. Price: $9.99 License: Open-source code, proprietary data Humble Indie Bundle #1
	And Yet It Moves A platform game in a world of paper collage you can rotate at will, turning walls into floors, slides into platforms and moving stacks of rocks (or even enemies). Price: $9.99 / 8.99€ License: Proprietary
Savage 2 A fantasy first-person shooter, action role-playing game (in player role) and real-time strategy (in commander role) multiplayer game. Price: Free / $9.99 (Premium Account) License: Proprietary See also Heroes of Newerth, a fantasy strategy game inspired in DotA ($30).
	Enemy Territory: Quake Wars A futuristic, objective-driven and class-based multiplayer first person shooter featuring the fight between the Earth’s Global Defense Force and the alien Strogg. Available at shops License: Proprietary
Penumbra (Overture, Black Plague) A series of exploration-based horror games. Price: 16.20€ (demo available) License: Open-source code, proprietary data See also Amnesia: The Dark Descent.
	World of Goo A physics-based puzzle game. Truly a work of art. Price: $20 License: Proprietary Humble Indie Bundle #1
Bionic Heart A science-fiction visual novel with interactive scenes (you can choose between different actions which change the ending of the story). Price: 12.70€ + VAT (demo available) License: Proprietary
	Revenge of the Titans A tower defense game with RTS elements. Price: 10.66€ + VAT License: Open-source code (not yet available), proprietary data Humble Indie Bundle #2

There are many more GNU/Linux-compatible games out there. Check out the other Humble Indie Bundle games, for instance. You may also follow LinuxGames to keep up with the latest news.

Related posts:

1. Debian Games Team Meeting This announcement was provided by Martin Erik Werner. I’m reproducing...

Un sistema operatiu és un programa que gestiona el maquinari d’un ordinador, proporciona una base per a d’altres programes i fa d’intermediari entre l’usuari de l’ordinador i el maquinari (fent així el seu ús més fàcil, eficient i segur).

El primer sistema operatiu va ser creat el 1956 per General Motors, per a un mainframe d’IBM. Per a més informació: History of Operating Systems, per Ayman Moumina (versió PDF).

Crides a sistema

El diagrama d’una crida a sistema és el següent:

El sistema disposa d’un vector anomenat Interrupt Descriptor Table (IDT) que determina la funció a invocar per a cada crida al sistema (o excepció per maquinari).

Processos

• Un procés és la unitat bàsica d’assignació de recursos i té com a mínim un fil.
• Un fil (també flux o thread) és la unitat bàsica de planificació per a l’execució d’instruccions.

Per defecte, els processos no comparteixen recursos (memòria, descriptors de fitxers ni fils) entre ells. Algunes de les seves propietats són el PID (identificador del procés) i en UNIX l’UID (usuari propietari) i el GID (grup propietari). En sistemes Linux també poden tenir personalitat, el qual permet canviar el comportament d’algunes crides a sistema per motius de compatibilitat.

Al llarg de la seva vida un procés passa per diferents estats. En termes generals, aquests es poden representar amb el següent graf:

El Process Control Block (PCB) emmagatzema la informació relativa a un procés, com ara els identificadors ja mencionats, l’estat, el PC, el contingut dels registres l’últim cop que ha estat interromput, informació per a la gestió de memòria, la llista de fitxers oberts, estadístiques que el sistema operatiu consideri rellevants, procés pare i fills, així com altres dades (prioritat del procés, restriccions de memòria o fitxers, etc). Aquesta estructura de dades (anomenada task_struct, en Linux) és generada quan es crea el procés i no s’allibera fins que el procés mor i el seu pare (o, si aquest no existeix, l’init) el recull.

El sistema operatiu inclou funcions de comptabilitat (accounting) i cada «tick» (equivalent a un determinat nombre de cicles de rellotge) s’encarrega de decidir quin ha de ser el procés actiu.

Alguns serveis relacionats amb els processos (Linux)

Optimitzacions
Una possible optimització per millorar l’eficiència d’un fork és el copy-on-write (COW), que consisteix en no duplicar la memòria del procés fins que un dels dos la vulgui modificar (així és especialment útil, per exemple, quan es clona un procés per mutar-lo tot seguit, ja que llavors s’evita del tot haver de copiar-ne la memòria).

Fils (threads)

Els fils són més ràpids de crear i destruir que processos sencers, i comparteixen memòria i descriptors de fitxers.

Per treballar amb ells utilitzem la API de fils de POSIX. Aquesta ens deixa manipular fils d’usuari que poden estar mapejats sobre fils del sistema (kernel threads) de forma molts-a-un, un-a-un o un-a-molts.

En el sistema Linux cada fil del sistema és identificat per un identificador LWP (Light-Weight Process), el qual ens permet enviar-li senyal. Això no és així amb d’altres sistemes operatius (per exemple, algunes versions de Solaris), els quals només permeten adreçar senyals a processos sencers.

Problemes amb la concurrència

En un programa multi-thread amb recursos compartits entre els diferents fils podem trobar-nos amb problemes (per exemple, si dos fils accedeixen a la mateixa variable alhora). Poden produir-se errors molt difícils d’identificar (race conditions).

La solució als problemes de concurrència és l’ús de Mutex (exclusió mútua o locks) per protegir les seccions crítiques del codi. Es poden implementar amb espera activa (busy waiting) o bé adormint el fil. Al implementar aquestes mesures cal evitar el problema de l’abraçada mortal (deadlock).

L’API de POSIX ens proporciona les següents funcions útils:

• pthread_mutex_trylock: intenta reservar un recurs i retorna indicant si ho ha aconseguit o no.
• pthread_mutex_lock: reserva un recurs (esperant que estigui lliure, si cal).
• pthread_mutex_unlock: allibera un recurs prèviament reservat.

Planificació

Hem mencionat abans que cada tick el sistema operatiu s’encarrega de decidir quin procés s’ha d’executar: aquesta tasca la fa el planificador (scheduler). Realment, però, aquest es divideix en varis components:

• Planificador a llarg termini (Long-term scheduler / Job Scheduler): gestiona la cua de «ready» (llista de processos residents en la memòria principal i a punt per executar-se).
• Planificador a curt termini (Short-term scheduler / CPU Scheduler): selecciona els processos / fils que s’executen en cada moment.

El planificador a curt termini es pot executar de forma «preemptiva» (preemptive), si el nucli obliga a parar al fil, o «no preemptiva» si és el fil qui abandona la CPU (perquè fa una crida bloquejant -una operació d’entrada/sortida, una espera, etc.- o acaba). Quan el canvi és «preemptiu» hi ha un canvi d’estat de «running» a «ready».

Polítiques de planificació

Algunes estratègies segons les quals es pot dur a terme la planificació:

• First-Come, First-Served (FCFS o FIFO)
  És la més senzilla de totes: s’executa el primer programa que estigui a punt, fins que aquest torni a cedir el control al sistema operatiu. Veiem que es tracta d’una política no «preemptiva».
• Round Robin (RR)
  Cada procès té la CPU durant un temps prefixat (quantum) o fins que es bloqueja (per ex., inicia una operació d’entrada/sortida o una espera).

En la pràctica s’acostuma a utilitzar un model híbrid de varies estratègies i pot ser que s’utilitzin les estadístiques proporcionades pel sistema de comptabilitat (accounting).

A més, molts sistemes permeten que l’administrador estableixi prioriats diferents a certs processos. En aquest cas, però, cal evitar problemes com el de starvation (que un procés tingui tan baixa prioritat que no arribi a executar-se mai).

El planificador a mig termini (medium-term scheduler)

Quan s’executen moltes aplicacions concurrents (o bé, algunes aplicacions especialment pesades), pot ser que no càpiguen totes les instruccions i dades dels programes en la memòria RAM. Quan aquest és el cas, molts sistemes operatius moderns són capaços de moure part de la memòria que no s’estigui utilitzant al disc dur (operació que es coneix com a swap out; la destinació al disc pot ser tant un fitxer especial -Windows- com una partició d’intercanvi -UNIX-) per a fer lloc per a més dades. Quan les dades mogudes tornen a ser necessàries (perquè és el torn d’executar-se d’un programa que les necessita), aquestes es tornen a copiar a la memòria, movent algunes altres dades al disc si és necessari.

Si hi ha massa processos actius, pot arribar-se a una situació de sobrepaginació, on el sistema estigui més temps intercanviant dades de programa entre la memòria i el disc que executant els programes en sí. Per evitar això, s’introdueix el planificador a mig termini, el qual s’encarrega de controlar la quantitat de processos que s’executen simultàniament (posant en pausa alguns processos de la cua de «ready»).

Memòria

Podem parlar d’adreces físiques (reals) i d’adreces lògiques. Un component hardware, la unitat de gestió de memòria (Memory Management Unit, MMU) s’encarrega de fer la traducció, vigilar que un programa no es surti del seu espai de memòria, etc. La memòria d’un mateix programa és pot separar en diferents seccions: codi, heap (no executable), pila (stack;  no executable), etc.

Assignació de memòria

• Paginació
  La memòria es divideix en marcs (frames) d’una mida preestablerta (per exemple, 4KiB), cadascun dels quals pot acollir una pàgina.
  La paginació presenta un problema de fragmentació interna, ja que quan la quantitat de memòria requerida per un programa no és múltiple de la mida de pàgina, es desaprofitarà part d’un marc.
• Segmentació
  Amb el sistema de segmentació la memòria es reserva un segment de memòria per a cada secció del programa (instruccions, pila, heap, etc). Així la memòria es divideix de forma lògica i cada segment de memòria pot tenir assignats uns permisos diferents (per exemple, si el seu contingut és executable com a instruccions o no). Per accedir a memòria segmentada s’utilitzen adreces compostes per un identificador del segment i un desplaçament (nombre de bytes -quan l’adreçament de memòria és a nivell de byte- a sumar a l’adreça inicial del segment).
  La memòria corresponent a un segment ha de ser contigua, de manera que en aquest cas tenim un problema de fragmentació externa: quan entre dos segments queda un espai de memòria buit, aquest no pot ser utilitzat si és més petit que les seccions dels programes.

Per reduir els problemes del sistema de segmentació, a la pràctica s’acostuma a utilitzar una combinació de tots dos, la segmentació paginada, on els segments de memòria que es troben dividits en pàgines. Així la memòria té l’estructura lògica de la segmentació però amb la fragmentació interna de la paginació (la qual aprofita millor la memòria).

Unitat de gestió de memòria (MMU)

Ja hem comentat breument que la MMU s’ocupa de traduir les adreces lògiques (tal com les veuen els programes) a adreces físiques. També s’encarrega d’evitar l’accés a memòria aliena al programa que s’està executant i, quan l’assignació fa ús d’un sistema de segmentació, de fer respectar altres possibles restriccions.

Amb aquesta finalitat, el sistema operatiu disposa d’una taula de pàgines. En la majoria de sistemes moderns, la MMU també disposa d’una unitat de memòria cau (cache) anomenada TLB (translation lookaside buffer).

Quan un programa accedeix a memòria, es cerca la traducció de l’adreça virtual que proporcioni al TLB. Si la traducció es troba a la memòria cau (TLB hit), retorna l’adreça física i l’accés a memòria pot continuar. En canvi, si no hi és (TLB miss), es passa a cercar la traducció a la taula de pàgines. La taula de pàgines inclou, juntament a l’adreça virtual i l’adreça física, un bit de validació que indica si l’adreça física és vàlida o si el contingut cercat ha estat mogut a l’espai d’intercanvi (és una pàgina no resident); si és el darrer cas, es produeix una excepció i es notifica al sistema operatiu perquè carregui les dades i actualitzi la taula de pàgines. Un cop s’ha trobat una adreça vàlida a la taula de pàgines, aquesta es grava a la TLB i es repeteix l’accés a memòria.

En sistemes de 32 bits i amb una mida de pàgina de 4KiB, hi poden haver 2^20 pàgines (2^32 bytes / 4 KiB), el qual requereix una taula de pàgines de 4MiB. Per reduir la mida de la taula de pàgines es pot implementar una taula de pàgines multi-nivell (directori de pàgines -> taula de pàgines).

Memòria dinàmica (heap)

Quan un programa no sap quanta memòria necessitarà en temps de compilació, pot reservar memòria de forma dinàmica en temps d’execució. En sistemes Linux, això es fa amb la crida a sistema brk (en C: brk i sbrk).

La llibreria estàndard del llenguatge C ofereix un seguit de funcions de més alt nivell que s’encarreguen de gestionar aquest tipus de crides de forma més eficient (reserven espai per avançat per reduir el nombre de crides a sistema, re-aprofiten l’espai anteriorment alliberat, etc). Es tracta de les funcions malloc i free.

Bibliografia

• Operating System Concepts; Silberschatz, Galvin and Gagne.
• Understanding the Linux Kernel; Bovet and Cesati.
• Pàgina web de l’assignatura (FIB)

Veure també…

• Apunts de Sistemes Operatius, per Marc Mauri.

One comment
© Siegfried-Angel Gevatter Pujals, 2010. | Permalink | License | Post tags: apunts, fib, linux, operating systems, sistemes operatius

Balsamiq source XML

Related posts:

1. Debian Games Team Meeting This announcement was provided by Martin Erik Werner. I’m reproducing...
2. Packaging: Test-building your packages Short version: how to test-build Debian/Ubuntu packages in a chroot...
3. One week with Debian Jaunty was a great experience, until around a month (or...