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...

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...

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

It extracts the existing meta-data, opens it in your favourite editor, writes it back to the original PDF and finally removes the temporary files it generated.

#! /bin/sh

if [ ! -f "$1" ]
then
	echo "Usage: $0"
	exit 1
fi

FILE=$(tempfile --prefix=pdf-metadata-)
pdftk "$1" dump_data output $FILE
creation_time=$(stat -c %Y $FILE)
$EDITOR $FILE

if [ "$(stat -c %Y $FILE)" -le $creation_time ]
then
	echo "Information not modified, aborting."
	rm -f "$FILE"
	exit 2
fi

output_file=$(tempfile --prefix=pdf-modified-)
pdftk "$1" update_info $FILE output "$output_file" || \
	(rm -f $FILE && exit 3)

mv -f "$output_file" "$1"
rm -f $FILE

I thought I’d share it in case anyone else finds it useful. Do whatever you want with it; if you want to use it somewhere serious, the ISC License is fine.

2 comments
© Siegfried-Angel Gevatter Pujals, 2010. | Permalink | License | Post tags: bash, scripts

Some time ago I found out about Book Sneeze, a service by Thomas Nelson offering free books in exchange for reviewing them on your blog (the reviews aren’t required to be positive).

I decided to give it a try, and a couple days after signing up my account got approved. The website shows a changing selection of a bit more than a handful books available at any time. When I visited the page, most stuff available seemed to be about religion or self-help, which I’m not really interested in, and I decided for the book which looked the most like a novel. It happened to be Andy Andrews’ «The Heart Mender» (formerly published as Island of Saints).

After the usual delay (snail post is painfully slow here) I received the expected package, and they were even so nice as to include a second copy to give away. I’ll see what I do with it :). Anyway, here goes the review!

When I started reading the book, it surprised me twofold: first of all, it didn’t begin with the actual story I had expected, but with a narration of how the author got to write the book, after finding a box containing WWII artefacts and a photo buried in his backyard. Even more surprising, though, I got captivated by it after reading just the first few pages, something many few books achieve so fast.

After a few chapters exploring the origin of the artefacts, the author begins with the actual story of how Josef Landerman, Lieutenant of a German U-Boat sent to the Gulf of Mexico, ends up at the mercy of Helen Mason. Helen, a widow who hasn’t been able to overcome her ill fortune, is thus confronted with the choice of saving the life of someone wearing the same uniform that killed her husband years ago. Even if Helen decides to help him, what will await him so far from home?

While it’s sold as a romance focusing on the topic of forgiveness, the book doesn’t miss its fair share of adventure and it is a pleasurable read. I can only recommend it.

No comments
© Siegfried-Angel Gevatter Pujals, 2010. | Permalink | License | Post tags: book review, books

1. Installing CAFF (CA – Fire and Forget)

Easy.

sudo aptitude install signing-party

2. Configuring CAFF

For this we open up ~/.caffrc and write in something like this:

$CONFIG{'owner'} = 'Siegfried Gevatter';
$CONFIG{'email'} = 'name@example.com';
$CONFIG{'keyid'} = [ qw{1CFC22F3363DEAE3} ];
$CONFIG{'gpg-sign-args'} = 'save';

The last line avoids the default behavior of dropping you into an interactive gpg session for each key, and just signs all IDs automatically after asked for confirmation. I’ve also set the trust level to 2 (“I have checked this key casually.“) by creating a ~/.caff/gnupghome/gpg.conf file with:

personal-digest-preferences SHA256
cert-digest-algo SHA256
default-cert-level 2

To further streamline the process, I’ve defined an alias in my ~./.bashrc so that CAFF won’t ask for confirmation for every single e-mail it sends:

alias caff="caff -m yes"

3. Installing and configuring sSMTP

Now so that CAFF can send out the mails, we need a mail agent. If you don’t have one already, you’ll need to install one and configure it to work with your e-mail setup (in my case, Gmail). I decided to go with sSMTP, but you can use any other MTA of your choice.

I followed those instructions to configure it:  Send Mail with Gmail and sSMTP. Additionally, I changed the permissions of the /etc/ssmtp/ssmtp.conf file to 640 (-rw-r—–) and the owner to root.rainct (where rainct is my username) so that the plain-text password in it is protected.

4. Using CAFF

That’s it. Well, at least for the setup part, now the real work begins, verifying and signing all the keys. In my case I had them printed out on paper and just typed “caff <id1> <id2> <…>” (eg. “caff 363DEAE3“). CAFF then downloads the keys, asks for confirmation for each of them so you can double-check, and finally e-mails the signatures to everyone.

By the way, in case you accidentally sign the wrong key (eg. one you had on your list but whose owner you didn’t met), you can still revoke your signature (see this “Help revoking a signature” mailing list post).

No comments
© Siegfried-Angel Gevatter Pujals, 2010. | Permalink | License | Post tags: Debian, events, Ubuntu

Installation

If you use Ubuntu you can grab packages from Zeitgeits’s PPA, else get the tarball and install it (# make; make install). Once installed, start “zeitgeist-daemon” and leave it running in the background (at first it may be busy for some time going through all of your Firefox history, but after that you shouldn’t notice it).

Zeitgeist comes with a public Python module providing some convenience functions. This module makes it very easy to play with Zeitgeist from an interactive Python instance, which is something I recommend you to do while reading this post. Thanks to it, you can get access to Zeitgeist’s D-Bus interface simply doing: from zeitgeist import dbusutils; iface = dbusutils.DBusInterface().

API Examples

For brevity, I’m only going to show some examples, but not explain what every parameter used in the call stands for. You’ll need to look at the DBus API documentation to completely understand them.

Also, I’m using Python for the examples, but the same works with very little modifications in any other language (as long as it has D-Bus bindings).

iface.GetItems([u'file:///home/rainct/todo'])
Returns a dictionary with basic information about the “todo” file in my home directory; uri, text (usually the filename), mimetype, tags, whether it’s bookmarked or not, etc. The values for some keys, like “timestamp”, are empty because they are only relevant for events, which are items put into a timeline (yes, this is a bit confusing, in future versions of Zeitgeist we will clearly differentiation between events and items).

iface.FindEvents(time.time() - 24*3600, time.time(), 5, False, 'event', [])
Returns the five last events (or less, if less than five events where logged within the last twenty-four hours). If you opened the same file twice, it will have two events; to avoid this change 'event' to 'item'.

iface.FindEvents(0, 0, 10, True, 'event', [])
Returns the ten first events ever registered with Zeitgeist which happened first (the sorting is always done by timestamp, not by insertion order).

iface.FindEvents(0, 0, 2, False, 'mostused', [])
Returns the last two events for to the items (URIs) which are used the most often.

iface.FindEvents(0, 0, 0, False, 'item', [{'tags': [u'zeitgeist'], 'bookmarked': True}])
Returns all events (when there are more than one with the same URI, only the most recent of them because of the 'item' parameter) which are bookmarked and have the tag “zeitgeist”.

iface.FindEvents(0, 0, 0, False, 'item', [{'tags': [u'zeitgeist']}, {'mimetypes': ['text/x-python'], 'bookmarked': True}])
Returns all events (when there are more than one with the same URI, only the most recent of them because of the 'item' parameter) which are bookmarked and have the tag “zeitgeist”.

iface.FindEvents(0, 0, 0, False, 'item', [{'tags': [u'zeitgeist', 'engine']}, {'mimetypes': ['text/x-python'], 'bookmarked': True}])
Returns all events (without duplicated URIs) which either have the tags “zeitgeist” and “engine” or, alternatively, are Python files (determined by their mimetype) and are bookmarked.

iface.CountEvents(0, 0, 'item', [{'tags': [u'zeitgeist', 'engine']}, {'mimetypes': ['text/x-python'], 'bookmarked': True}])
Same as above, but returning only the amount of results that the previous call would yield.

iface.FindApplications(time.time() - 3600*24*30, 0, [{'mimetypes': ['text/x-python']}])
Returns the path to the .desktop files of all applications which were used to manipulate Python files within the last 30 days (eg., in my case: [u'/usr/share/applications/geany.desktop', u'/usr/share/applications/gedit.desktop' ]).

iface.GetTags(0, 0, 5, u'a%')
Returns the five most used tags which start with “a” (case insensitive) in a list of tuples containing both the tag name and the amount of times it was used.

iface.GetLastInsertionDate(u'/usr/share/applications/gedit.desktop')
Returns the timestamp of the last event related to Gedit.

iface.connect('EventsChanged', callback_function); import gobject; gobject.MainLoop.run()
Calls callback_function every time a new event is inserted into the database or an existing one is modified. The callback function receives a list containing in the first place a string representing the type of change (“added”, “modified”, “deleted”) and in second place a list containing the affected events (or, in case of deletion, only a list with the deleted URIs).

Related posts:

1. Zeitgeist since UDS Quite some stuff has been going on in Zeitgeist since...
2. Zeitgeist is out! World, the first Zeitgeist release is out! From the release...
3. Here is Zeitgeist 0.2.1! One month after the first Zeitgeist release (0.2), here is...

After searching for a while and trying out some stuff, the solution is easy. Just open file /etc/modprobe.d/alsa-base.conf and add the following lines:

options snd-pcsp index=-2
alias snd-card-0 snd-hda-intel
alias sound-slot-0 snd-hda-intel
options snd-hda-intel model=hp-m4
options snd-hda-intel enable_msi=1


(Before finding the previous solution I tried upgrading ALSA -following this instructions- so I’ve tested this with ALSA 1.0.20, but I guess 1.0.18 should work aswell).

Related posts:

1. No sound problem with Wolfenstein: Enemy Territory I don’t really play much, but of the few games...
2. Portàtil: Ahtec Sense XHL90 Ja fa bastant temps que tinc el meu portàtil i...
3. Getting your scanner to work with Ubuntu (gt68xx) You try to use your scanner with XSane but it...

Pels qui no hagueu seguit la conversa a la llista, el Nadal passat vaig comprar el meu primer portàtil, un Ahtec Sense XHL90. La configuració per la qual em vaig decidir és: processador Intel Core 2 Duo P7350  (2.00 Ghz, 3MB de memòria cau i tecnologia Penryn), 4GB de memòria RAM a 800Mhz, 250GB de disc dur a 5400rpm, bateria de nou cel·les i targeta wireless Intel 5300AGN.

La pantalla és de 15.4 polzades amb una resolució nativa de 1280×800, té una targeta gràfica nVidia Geforce 9600M GT amb 512MB de memòria dedicada i també duu gravadora de DVD, webcam de 2.0 megapixels i lector d’empremtes dactilars (col·locat just a sota del touchpad, entre els dos botons, posició que trobo molt ben triada). A més, ha estat una sorpresa veure que també porta lector de targetes SD, infrarojos, mòdem, ranura PCMCIA i Kensington lock.

Bé, deixo d’avorrir-vos enumerant tot el que té i passo a explicar una mica… Em vaig decidir per aquest portàtil després que algú nombres la casa Ahtec a la llista, i la veritat és que n’estic molt content. La carcassa podria ser un pèl millor, però a la fi és el de dins el que compta i pel preu de la màquina (poc més de 900€) no he sabut trobar cap oferta semblant amb les mateixes prestacions.

Com a aspecte negatiu, la pàgina web està en castellà, però quan he trucat per telèfon m’han atès en català sense problemes. L’ordinador ve sense sistema operatiu i, tal com m’havia confirmat el venedor, l’Ubuntu hi funciona gairebé a la perfecció. L’únic que em va caldre fer va estar crear el fitxer /etc/modprobe.d/sound amb el contingut «options snd-hda-intel model=tohsiba» perquè sinó el so no funcionava al tornar de la suspensió, però a la Jaunty fins i tot això ja està solucionat. L’únic component que em dóna problemes és el lector d’empremtes dactilars: no he trobat cap programa que el detecti. Per a més detalls en quant a la compatibilitat, vegeu la pàgina que he creat a la wiki d’Ubuntu: LaptopTestingTeam/AhtecSenseXHL90.

Del rendiment n’estic molt satisfet (sobretot tenint en compte que el meu ordinador anterior ja era més aviat vell i tenia un Celeron), però si pogués tornar a triar agafaria un disc dur de 7200rpm. La gravadora de DVD fa bastant soroll al llegir, casi sembla que estiguis fent crispetes xD, però com que tampoc la faig servir gaire ja m’està bé. Una altre cosa que haurien pogut fer millor és el teclat: és agradable d’utilitzar, però segons quines combinacions de tecles (de quatre tecles o més) no funcionen gaire bé, cosa que no entenc tenint en compte que l’ordinador es publicita com a apte per a jocs; per a ús normal això no és cap problema, però jugant (per exemple, a l’Enemy Territory) sí que es nota.

La bateria dura unes 3-4 hores fent-ne un ús normal (amb W-LAN i Bluetooth activats), i poc més d’una hora jugant. Un altre aspecte en que m’he fixat és que a vegades surt aire de sota les tecles, però normalment només refrigera pel costat. Ah, i la BIOS que porta és la pitjor que he vist mai: triga 15 segons en encendre’s (i mentre ho fa el ventilador va al màxim) i no permet fer res a part de canviar l’ordre d’inici (no permet ni protegir-la amb contrasenya!).

One comment
© Siegfried-Angel Gevatter Pujals, 2009. | Permalink | License | Post tags: laptop, Ubuntu