Sanity

• AdBlock Plus – I’m not sure how anyone can use a web browser without AdBlock. It’ll make sure you don’t see ads, anywhere.

Productivity

• Pocket – If you have a tablet, this is the extension you need. Save interesting reads so you can access them later from your computer, smartphone or tablet. It also nicely extracts the text from the page, leaving it free of clutter.
• Google Tasks – Who doesn’t want to be able to save TODO items just by typing “t whatever” into the omnibox? I haven’t tried it, but some may prefer Better Google Tasks.

Privacy

• HTTPS Everywhere – Protect your privacy when using insecure networks. This extension forces many popular sites to always encrypt communications.
• DoNotTrackMe – If you’re using AdBlock you won’t see ads, so what does it matter whether they are customized to your interests? Use this extension to stop ad networks from tracking you.
• Extra: Facebook Link Rewriter, Unsocial Reader for Facebook.

Social

• Rapportive – For GMail users, this extension adds a sidebar with information about who you’re talking to (LinkedIn profile, etc).
• Google +1 Button – Add a “+1″ button to Chrome.

What extensions do you use? Let me know about your favorite one.

3 comments
© Siegfried-Angel Gevatter Pujals, 2012. | Permalink | License | Post tags: chrome, recommendations

If you’re interested in using Zeitgeist from C instead, see the libzeitgeist examples; to use it with C++/Qt, Trever’s «a web browser in 4 steps» may be of interest.

First things first

In case you’re not familiar with Zeitgeist, it may prove helpful to first read Mikkel’s introduction to Zeitgeist post.

If that’s too much to read, just should know that Zeitgeist is an event log. Like the history in your browser, it keeps track of what websites you open at which point in time. It also keeps track of when you close them, and of what browser you used, since it’s a system-wide service. Furthermore, it does the same for files, conversations, e-mails, and anything else you want to insert into it.

So Zeitgeist is a database of events, and an event can be pretty much anything. But what does it look like? It’s main attributes are the following:

• timestamp – when did the event happen (milliseconds since Unix epoch)
• interpretation – what sort of event is it (eg. opened, closed)
• manifestation – why did it happen (user activity, notification…)
• actor – which is the primary application involved
• origin – where did it come from (eg. website where you clicked the link that opened this page)

Additionally, each event has one or more subjects, which have the following attributes:

• uri
• current_uri – updated URI if it changed since the event
• interpretation – abstract type (document, image, video…)
• manifestation – how it is stored (file, remote object, website)
• origin – parent folder for files, domain name for websites
• mimetype
• text – a title for the event (eg. filename, website title…)
• storage – identifier for the storage medium of the subject (eg. local, online, pendrive X)

Retrieving recent data

Okay, so let’s say you want to know the last song you’ve listened to (if you have a Zeitgeist-enabled music player). It’s a simple as:

from zeitgeist.client import ZeitgeistClient
from zeitgeist.datamodel import *
 
zeitgeist = ZeitgeistClient()
 
def on_events_received(events):
    if events:
        song = events[0]
        print "Last song: %s" % song.subjects[0].uri
    else:
        print "You haven't listened to any songs."
 
template = Event.new_for_values(subject_interpretation=Interpretation.AUDIO)
zeitgeist.find_events_for_template(template, on_events_received, num_events=1)
 
# Start a mainloop - note: the Qt mainloop also works
from gi.repository import GLib
GLib.MainLoop().run()

This may need some explaining. We start by importing the Zeitgeist client and some associated data structures (such as Event and Interpretation), and create an instance of the client. The ZeitgeistClient class is a wrapper around Zeitgeist’s D-Bus API which not only makes it much nicer to use, but also makes it easy to install monitors (as we will see later) and provides convenient functionality such as automatic reconnection if the connection to the engine is lost.

To query for the most recent song, we just need to create a template with the restrictions we want to impose and submit it to Zeitgeist using the find_events_for_template call. If you haven’t read Mikkel’s post yet, please do so, as it introduces the structure of events and subjects (in short: an event has a timestamp, some other properties, and one or more subjects representing the resources -files, websites, people…- involved in the event).

The Python API is inherently asynchronous (if for some reason you need a synchronous API, you may still use the lower level ZeitgeistDBusInterface class), so we need to define a callback function to handle the results we receive from the Zeitgeist engine.

Finally, we need to create a main loop so the asynchronous functions can run.

Now this was a pretty simple example. Let’s make it more interesting. One song isn’t much, so let’s get the 5 most recent songs. Also, now we want both songs and videos.

The first part is pretty easy, we just need to change the num_events parameter. For the second extension, we have to change the event template. In fact, now we need two different event templates and the find_events_for_templates function, which takes an arbitrary number of event templates and ORs them. The result is as follows:

from zeitgeist.client import ZeitgeistClient
from zeitgeist.datamodel import *
 
zeitgeist = ZeitgeistClient()
 
def on_events_received(events):
    for event in events:
        print "- %s" % event.subjects[0].uri
 
tmpl1 = Event.new_for_values(subject_interpretation=Interpretation.AUDIO)
tmpl2 = Event.new_for_values(subject_interpretation=Interpretation.VIDEO)
zeitgeist.find_events_for_templates([tmpl1, tmpl2],
                                    on_events_received, num_events=5)
 
# Start a mainloop
from gi.repository import GLib
GLib.MainLoop().run()

This will work, but unless you’re lucky you’re likely to get some duplicate line. Why is this? Well, other than that you may have used the same file twice, don’t forget that what you are requesting are actually events. If you’ve started playing a given song, you probably also stopped playing it, so that’s actually two of them (an AccessEvent and a LeaveEvent). Since this isn’t what we want, we’ll change the query a bit:

zeitgeist.find_events_for_templates(
    [tmpl1, tmpl2],
    on_events_received,
    num_events=5,
    result_type=ResultType.MostRecentSubjects,
    storage_state=StorageState.Available)

By requesting the most recent subjects, vs. the most recent events, we can filter out events with duplicate URI. See the ResultType documentation for other modes you can use. Note particularly the MostPopularSubjects result type.

I also used the chance to introduce the storage_state parameter. This one will filter out events for files Zeitgeist knows aren’t available (this mostly means online resources won’t be shown if you don’t have a network connnection; there’s also support for handling external storage media, but because of problems with GIO this is currently disabled).

Last but not least, the find_events_for_* methods also accept a timerange parameter. It defaults to TimeRange.until_now(), but you may change it to TimeRange.always() (if for some reason you’re working with events in the future) or to any other time range of your choice. Here it’s important to note that Zeitgeist’s timestamps use millisecond precision.

For more advanced queries, you can use more complex combinations of events and subject templates. The rule to keep in mind here is that events are OR’d and subjects are ANDed.

Additionally, some field (actor, origin, mimetype, uri and current_uri) may be prefixed with an exclamation mark (“!”) for NOT, or you may append an asterisc (“*”) to them for prefix search. You can even combine the two operators together. Here’s an example of a template you could build:

subj1 = Subject.new_for_values(interpretation=Interpretation.SOURCE_CODE,
                               uri="file:///home/rainct/Development/*")
subj2 = Subject.new_for_values(uri="!file:///home/rainct/Development/zeitgeist/*")
tmpl1 = Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT,
                             subjects=[subj1, subj2])
templates = [tmpl1]

In my case, this template would fetch a list of the source code files I modified most recently but excluding those related to the Zeitgeist project.

Working with big sets of data

In case you’re trying to do something crazy, you may end up with a Zeitgeist query complaining that it exceeded the memory limit. You’re not supposed to do that. Instead, we provide some methods for working with large collections of events.

from zeitgeist.client import ZeitgeistClient
from zeitgeist.datamodel import *
 
zeitgeist = ZeitgeistClient()
 
def on_events_received(events):
    for event in events:
        print '- %s' % event.subjects[0].uri
 
def on_ids_received(event_ids):
    print 'A total of %d source code files were found.' % len(event_ids)
    print 'Fetching the first 100...'
    zeitgeist.get_events(event_ids[:100], on_events_received)
 
tmpl = Event.new_for_values(subject_interpretation=Interpretation.SOURCE_CODE)
zeitgeist.find_event_ids_for_templates(
    [tmpl],
    on_ids_received,
    num_events=10000, # you can use 0 for "all events", but do you really need to?
    timerange=TimeRange.from_seconds_ago(3600*24*30*3),
    result_type=ResultType.MostPopularSubjects)
 
# Start a mainloop
from gi.repository import GLib
GLib.MainLoop().run()

And there you have the source code files you worked with during the last 3 months, ordered from most to least popular (popularity is measured counting the number of events; for more precision, maybe you could limit the results to events with interpretation AccessEvent).

Why do we provide this mechanism instead of querying with a simple offset? Well, this avoids problems when the log changes (events are inserted or deleted). Have you ever been exploring the latest posts in some website, and as you change to the next page some of the results from the previous page show up again (because new posts have been added in the meantime)? With Zeitgeist this won’t happen.

Receiving information in real time

At this point you’re an expert at requesting all sorts of data from Zeitgeist, but now you want to show a list of the last kitten images you’ve viewed, updated in real time. Don’t worry, Zeitgeist can provide for this:

from zeitgeist.client import ZeitgeistClient
from zeitgeist.datamodel import *
 
zeitgeist = ZeitgeistClient()
 
def on_insert(time_range, events):
    # do awesome stuff with the events here
    print events
 
def on_delete(time_range, event_ids):
    # a previously inserted event was deleted
    print event_ids
 
templates = [Event.new_for_values(subject_uri='file:///home/user/kittens/*',
                                  subject_interpretation=Interpretation.IMAGE)]
zeitgeist.install_monitor(TimeRange.always(), templates, on_insert, on_delete)
 
# Start a mainloop
from gi.repository import GLib
GLib.MainLoop().run()

It’s important to note that on_delete won’t be called when an image is deleted (that’d be a newly inserted event with interpretation=DELETE_EVENT); rather, it’s called when a previously inserted event is deleted (for example, using the “forget recent history» option in Activity Log Manager).

In case you’re curious: for best performance, this doesn’t actually use D-Bus signals. Instead, this little call will setup a D-Bus object behind the scenes and register it with the Zeitgeist engine, so it can notify said object when (and only when) an event of its interest is registered.

To stop receiving notifications for a template, you’ll need the save the object returned by the install_monitor call:

m = zeitgeist.install_monitor(TimeRange.always(), templates, on_insert, on_delete)
zeitgeist.remove_monitor(m)

Pro Tip: You can use the Zeitgeist Explorer GUI to quickly try out different queries (note: it’s still work in progress, so much funcionality is missing, but it does work somewhat).

Contextual awesomeness: finding related events

By now you’re familiar with retrieving events and keeping them up to date. Now it’s time for a little secret:

import time
from zeitgeist.client import ZeitgeistClient
from zeitgeist.datamodel import *
 
zeitgeist = ZeitgeistClient()
 
def on_related_received(uris):
    print 'Related URIs:'
    for uri in uris:
        print ' - %s' % uri
 
query_templates = [Event.new_for_values(
    subject_interpretation=Interpretation.SOURCE_CODE,
    subject_uri='file:///home/rainct/Development/zeitgeist/*',
    subject_mimetype="text/x-vala")]
 
result_templates = [Event.new_for_values(
    subject_interpretation=Interpretation.WEBSITE,
    subject_manifestation=Manifestation.WEB_DATA_OBJECT)]
 
now = time.time()*1000
zeitgeist.find_related_uris_for_events(
    query_templates,
    on_related_received,
    time_range=TimeRange(now - 1000*3600*24*30*6, now),
    result_event_templates=result_templates,
    num_events=10)
 
# Start a mainloop
from gi.repository import GLib
GLib.MainLoop().run()

This little query example will return up to 10 websites I used at the same time as the Vala files inside my Zeitgeist directory, considering only data from the last 6 months. Nice, huh?

This is an experimental feature, and it doesn’t work well when operating on big inputs, so it’s usually better to use the find_related_uris_for_uris variant (which replaces the first query_templates parameter with a list of URIs).

Advanced searching: the FTS extension

Some people think prefix searches aren’t good enough for them, and this is why the Zeitgeist engine ships by default with a FTS (Full Text Search) extension.

Using the methods provided by this extension you can perform more advanced queries against subjects’ current_uri and text properties (unlike the name may suggest, the FTS extension doesn’t index the content of the files, but just the information in the event).

This is exposed as zeitgeist_index_search in libzeitgeist (the C library), but unfortunately isn’t currently available in the Python API. If you still need it, you’ll have to fallback to pretty much using the D-Bus interface (you still get reconnection support, though). Here’s an example:

from zeitgeist.client import ZeitgeistClient
from zeitgeist.datamodel import *
 
zeitgeist = ZeitgeistClient()
index = zeitgeist._iface.get_extension('Index', 'index/activity')
 
query            = 'hello' # search query
time_range       = TimeRange.always()
event_templates  = []
offset           = 0
num_events       = 10
result_type      = 100 # magic number for "relevancy" (ResultType.* also work)
 
def on_reply(events, num_estimated_matches):
    print 'Got %d out of ~%d results.' % (len(events), num_estimated_matches)
    events = map(Event, events)
    for event in events:
        print ' - %s' % event.subjects[0].uri
 
def on_error(exception):
    print 'Error from FTS:', exception
 
index.Search(query, time_range, event_templates,
             offset, num_events, result_type,
             reply_handler=on_reply, error_handler=on_error)
 
# Start a mainloop
from gi.repository import GLib
GLib.MainLoop().run()

The most interesting thing here is the query parameter. Quoting from the C documentation:

The default boolean operator is AND. Thus the query foo bar will
be interpreted as foo AND bar. To exclude a term from the result
set prepend it with a minus sign - eg foo -bar. Phrase queries
can be done by double quoting the string "foo is a bar". You can
truncate terms by appending a *.

There are a few keys you can prefix to a term or phrase to search
within a specific set of metadata. They are used like key:value.
The keys name and title search strictly within the text field of
the event subjects. The key app searches within the application
name or description that is found in the actor attribute of the
events. Lastly you can use the site key to search within the
domain name of the subject URIs.

You can also control the results with the boolean operators AND
and OR and you may use brackets, ( and ), to control the operator
precedence.

Modifying the log

So far we’ve only queried Zeitgeist for information, let’s get a bit more active.

You can delete events from Zeitgeist with the following query:

from zeitgeist.client import ZeitgeistClient
 
zeitgeist = ZeitgeistClient()
 
def on_deleted(timerange):
    print 'Deleted events going from %s to %s' % (timerange[0], timerange[1])
 
event_ids = [50] # put the IDs of the events you want to delete here
 
zeitgeist.delete_events(event_ids, on_deleted)
 
# Start a mainloop
from gi.repository import GLib
GLib.MainLoop().run()

The confirmation callback will receive a timerange going from the first to the last event. If no events were deleted (because they didn’t exist), you’ll get (-1, -1).

And now for the interesting part. If your application involves resources (files, websites, contacts, etc.) of any sort, you’ll probably want to let Zeitgeist know that you’re using them. It’s time that you write a data-source!

We start by registering the data-source. Here we go:

import time
from gi.repository import GLib
from zeitgeist.client import ZeitgeistClient
from zeitgeist.datamodel import *
 
zeitgeist = ZeitgeistClient()
 
def on_status_changed_callback(enabled):
    """ This method will be called whenever someone enables or disables
        the data-source. """
    if enabled:
        print 'Data-source enabled and ready to send events!'
    else:
        print 'Data-source disabled; don\'t send event, they\'ll be ignored.'
 
def register():
    # Always use the same unique_id. Name and description can change
    # freely.
    unique_id = 'com.example.your.data.source'
    name = 'user visible name (may be translated)'
    description = 'user visible description (may be translated)'
 
    # Describe what sort of events will be inserted (optional)
    subject_template = Subject()
    subject_template.interpretation = Interpretation.PLAIN_TEXT_DOCUMENT
    subject_template.manifestation = Manifestation.FILE_DATA_OBJECT
    templates = []
    for interp in (Interpretation.ACCESS_EVENT, Interpretation.LEAVE_EVENT):
        event_template = Event()
        event_template.interpretation = interp
        event_template.manifestation = Manifestation.USER_ACTIVITY
        event_template.append_subject(subject_template)
        templates.append(event_template)
 
    zeitgeist.register_data_source(unique_id, name, description, templates,
                                   on_status_changed_callback)

Once that’s done (and if it is enabled), we are free to send our events:

def log(title, uri, opened):
    subject = Subject.new_for_values(
        uri=uri,
        interpretation=Interpretation.PLAIN_TEXT_DOCUMENT,
        manifestation=Manifestation.FILE_DATA_OBJECT,
        origin=GLib.path_get_dirname(uri),
        mimetype='text/plain',
        text=title)
    event = Event.new_for_values(
        timestamp=time.time()*1000,
        manifestation=Manifestation.USER_ACTIVITY,
        actor='application://your_application_name.desktop',
        subjects=[subject])
    if opened:
        event.interpretation = Interpretation.ACCESS_EVENT
    else:
        event.interpretation = Interpretation.LEAVE_EVENT
 
    def on_id_received(event_ids):
        print 'Logged %s (%d) with event id %d.' % (title, opened, event_ids[0])
 
    zeitgeist.insert_events([event], on_id_received)
 
if __name__ == '__main__':
    register()
 
    log('test.txt', 'file:///tmp/test.txt', opened=True)
    log('another_file.txt', 'file:///tmp/another_file.txt', opened=True)
    log('another_file.txt', 'file:///tmp/another_file.txt', opened=False)
    log('test.txt', 'file:///tmp/test.txt', opened=False)
 
    # Start a mainloop
    GLib.MainLoop().run()

If you don’t know what interpretation and manifestation your subject should have, you can use the following utility methods:

from zeitgeist.mimetypes import *
 
print get_interpretation_for_mimetype('text/plain')
print get_manifestation_for_uri('file:///tmp/test.txt')

Event better, with Zeitgeist 0.9 you can just leave the subject (but not event!) interpretation and manifestation fields empty, and they’ll be guessed the same way as if you used those utility methods.

Pro Tip: You can examine all registered data-sources and toggle whether they are enabled or not using the zeitgeist-data-sources-gtk.py tool.

Conclusion

Wow, I’m impressed if you’ve got this far. By now you should have quite a good idea on how to use the Zeitgeist API, and I’m looking forward to seeing what you do with it in your next awesome project.

If you have any problem with Zeitgeist, feel free to visit us on IRC (#zeitgeist on irc.freenode.net), or join our mailing list. We’ll also be at GUADEC next week, so if you’re there make sure to say hi!

In case you missed them, here are some useful links:

• Python API documentation
• C API documentation
• Zeitgeist project website
• Meta-project on Launchpad
• Bug tracker on FreeDesktop.org

2 comments
© Siegfried-Angel Gevatter Pujals, 2012. | Permalink | License | Post tags: gnome, zeitgeist

El Subversion permet únicament una forma de treballar centralitzada i no el trobo gaire agradable d’utilitzar, de manera que si tens l’opció et recomano que utilitzis un sistema més modern com ara el Bazaar (del qual ja en vaig parlar en un apunt anterior: Breu introducció al Bazaar) o el Git.

Ara bé, com que sovint no es té l’elecció (per exemple a l’incorporar-se en un projecte existent), aquí va el tutorial. Els conceptes que hi explico són molt bàsic, de manera que de fet es poden aplicar amb petits canvis a qualsevol altre sistema VCS.

http://www.youtube.com/watch?v=bcRiJ1yrgjM

No comments
© Siegfried-Angel Gevatter Pujals, 2012. | Permalink | License | Post tags: desenvolupament, subversion, svn, vcs

This new release introduced automatic language guessing, a feature I’ve wanted for a while, as well as spell checking (contributed by Joe Burmeister).

Version 0.3, released a year ago and which I didn’t announce here, did also introduce Undo/Redo, pausing, file history logging, a bunch of translations and some voice options. It’s sister project, python-espeak, did also get some bug fixes since its first release.

As usual, packages for both espeak-gui and python-espeak are available in my PPA, and since last month in Debian unstable. Make sure you also install libtextcat0 (version 2.2-8 or newer) to get the language identification support.

One comment
© Siegfried-Angel Gevatter Pujals, 2012. | Permalink | License | Post tags: gnome, gtk, Programari lliure, python, speech-synthesis, Ubuntu

The Debian/Ubuntu Games Team is organizing another meeting. If you’re into developing and/or packaging of games, or just generally curious about games in Debian/Ubuntu, you should join!

It will be held next Saturday, the 26th of November, in the #debian-games channel on irc.debian.org (also know as irc.oftc.net) at 10:00 UTC. More information is available on the wiki page Games/Meetings/2011-11-26.

The agenda starts off with the usual round of introductions, so if you’re new to the Team, say hi! Then we’ll be going through the action items from the last meeting, including work on the Debian Games LiveCD, and what’s up with the /usr/games/ path anyways?

Next we’ll be moving onto how the Games Team is faring in terms of members: are new recruits finding it comfortable, should we advertise more?

Next up it’s the squeeky penguin: Wheezy is somewhere in the not-completely-distant future, how does that affect the Games Team, should we be scuffling to get specific tasks done?

Then onto the recurring question of Sponsoring, and how to improve it, should we be utilising DebExpo more? What about our favourite PET?

Lastly, PlayDeb is doing some really neat stuff, would it make sense for our team to push some changes to PlayDeb? Would it make sense for PlayDeb to push changes to Debian Games?

Hopes are for a good discussion, and a merry time, hope to see you all there!

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: Debian, games, packaging

Dues regles com per exemple i es poden representar de forma agrupada de la següent manera: .

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 .

Un llenguatge s’anomena llenguatge incontextual si existeix una gramàtica que el genera. Existeixen algorismes 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 i que generen els llenguatges i . Suposem que els llenguatges no comparteixen variables (si no fos així, les podem reanomenar). Si definim la operació unió de gramàtiques llavors aquesta compleix .

També ho són per concatenació. Amb les mateixes condicions que abans, compleix .

Per l’operació estrella: compleix .

Per l’operació revessat: compleix ja que .

I per imatge de morfisme: i tal que . En aquest cas a la tupla de la gramàtica resultant es substitueix per .

En canvi, no són tancats per intersecció (si ) ni complementari.

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

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: formal-grammar, language-theory, theory-of-computation, universitat

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 . Utilitzarem , , , , … per denominar paraules.

Paraules: ab, bbb, a,
Longituds: |ab|=2, |bbb|=3, |a|=1, ||=0

Extenem la notació de les longituds per a occurències d’un mot dins d’un altre:

, ,

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

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

Amb la operació producte ( o ) representem la concatenació de dues paraules. Per exemple:

Element neutre:
Associativitat:

Amb representem el conjunt de tots els mots possibles que podem construir amb l’alfabet . Exemple per a :

Un llenguatge sobre l’alfabet és un subconjunt qualsevol . Per exemple:

• Paraules sobre l’alfabet {a, b} i de longituds múltiples de 2:
     
• Paraules amb algun símbol «a»:
     
• Paraules tals que tota ocurrència d’«a» ve seguida d’una occurència de «b»:
     
     

---

Denotem el llenguatge que conté només el mot buit amb ().

Definim la concatenació de dos llenguatges:

Exemples:


Element neutre:
No funciona amb el conjunt buit:
Associativitat:

Definim l’exponenciació de paraules:

Exemples:

Es compleix que: , .

Ídem per a l’exponenciació de llenguatges.

Definim també l’operació (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.


(Les paraules d’ són concatencions de 0, 1, 2, … paraules d’L.)

Per exemple:






De forma semblant definim l’operació , la qual no obliga a incloure el mot buit.





---

Denominem el revessat d’un mot : . Exemple:

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

També tenim el revessat d’un llenguatge:




Per exemple:

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


Commutativa amb la concatenació:




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:


, ,

Per a un llenguatge L:


 
 


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

Representem una substitució de la forma . Per exemple:

Si R és un conjunt de regles, podem indicar que es transforma en …

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 substitucions amb regles d’R

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

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: formal-grammar, language-theory, theory-of-computation, universitat

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.

…

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: databases, fib, sql, universitat

Com trobar els valors?

Taula resum

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

Considerem una funció real de variable real tal que existeix com a màxim un . Definim:

Definim el domini d’una funció:

I el recorregut d’una funció:

També:  

Exemple

Tipus de funcions

Una funció :

1. és parella
2. és imparella
3. és periòdica de període
4. és creixent (no decreixent)
5. és estrictament creixent
6. és decreixent
7. és estrictament decreixent
8. està acotada superiorment
9. està acotada inferiorment
10. està acotada
11. és injectiva
12. és exhaustiva
13. és bijectiva és injectiva i exhaustiva ()

Operacions amb funcions

Composició de funcions

Funció inversa

Asímptotes

és una asímptota vertical de la funció
és una asímptota horizontal… per la dreta per l’esquerra
és una asímptota oblíqua… per la dreta d’ i per l’esquerra (igual que per la dreta però amb )

Continuïtat

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

Derivabilitat

	és derivable en si . Aquest és igual a = = pendent de la recta tangent a la curva en el punt d’abscissa , .
	Recta tangent a on el punt d’: .

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: calculus, fib, maths, universitat

Naturals

Enters

Racionals

Irracionals

Reals

Relació d’ordre en

Elements notables d’un conjunt respecte de la

A està acotat inferiorment / és cota inferior d’A.
A està acotat superiorment / és cota superior d’A.
A està acotat A està acotat superiorment i inferior.

x és el ínfim d’A x és la major de les cotes inferiors d’A .
x és el suprem d’A x és la menor de les cotes superior d’A .

Teorema de l’extrem (també axioma del suprem)

acotat superiorment /
acotat inferiorment /

Valor absolut

Propietats:

2. Nombres complexos

La «unitat imaginària» és .

Els nombres complexos són els nombres , amb .

Conjunt dels nombres complexos: .

Donat

Donat , diem que el conjugat de és .

En , amb , sempre té solució en . Exemple:

(Recorda: )

Operacions

Suma

Producte

(Recorda: )

és un cos commutatiu.

L’invers de és

Quocient

Mòdul d’un nombre complex

Propietats:

Argument d’un nombre complex

angle que forma en el vector origen (0,0) i final (a,b) amb el semieix .

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

Com calcular la part real i la part imaginària sabent i ?

Representacions dels nombres complexos

Amb , la forma és anomenada la forma binòmica del nombre complex .

També podem expressar per mitjà de i de la següent forma: . Aquesta representació s’anomena forma trigonomètrica de .

Finalment, també utilitzem la forma polar:  

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

Operacions en forma polar

Si , per la fórmula de la potència: . Desenvolupant aquesta igualtat obtenim: , la fórmula de Moivre.

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: calculus, fib, maths, universitat

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

One comment
© 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!

4 comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: gnome, Programari lliure, zeitgeist

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:

2 comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: Programari lliure, zeitgeist

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

3 comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: intel, meego, mwc, tablet, touchscreen, Ubuntu

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 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 , i , l'operació resulta en productes escalars. En canvi, l'operació , amb les mateixes matrius, resultaria en 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  matrius, les possibles formes de posar els parèntesis són igual al nombre d'arbres binaris amb  fulles, el qual correspon a ( és el nombre de Catalan). Podem definir la següent funció per trobar el nombre mínim de productes escalars per multiplicar les matrius , …, :

Aquesta operació duplica càlculs → memorització! En resulta el següent codi C++ que triga temps :

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 , , =….

• 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) = .
• Si X i Y no acaben igual, pensem què passa amb LCS(X, Y).
  Quina de les dues? La més llarga.

Definim la funció = llargada de l'LCS(, ).

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: algorithmics, eda, fib, universitat

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

Queda una pregunta clau: ?

Reducció

Siguin i dos problemes decisionals. Diem que es redueix a en temps polinòmic si podem trobar un algorisme polinòmic , és a dir, que converteixi tota solució a en una solució d'.

En altres paraules, una reducció en temps polinòmic d' a  és un algorise .

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

Teorema: Si i , llavors .

Un problema decisional és NP-hard si tot problema en NP es pot reduir a ell en temps polinòmic. .

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

Teorema:
.

Teorema:

Teorema de Cook (~1970)
(va ser el primer problema NP-complet).

El problema decisional CIRCUIT-SAT pren com a entrada un circuit amb  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.

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: algorithmics, eda, fib, universitat

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'x caselles i  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  combinacions; amb  això són  possibilitats.
2. Podem limitar-nos a posar una única reina en cada línia. Això són  possibilitats; amb , .
3. Podem posar una única reina en cada fila i columna. Això són  possibilitats; amb , .
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' posicions, tal que  és la columna on va la reina i que al tauler anirà en .

Definim un vector -completable de la següent manera: sigui -completable, i . Les solucions al problema de les  reines són els vector -completables.

Observacions:

1. (les dues darrers condicions cobreixen les diagonals).
2. El vector ha de ser -completable i, a més, .
3. Tots els vectors són -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  objectes amb pesos  i valor  la combinació d'objectes amb pes total inferior a C amb el valor màxim».

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: algorithmics, eda, fib, universitat

Graf:

Graf dirigit (digraf):

Un camí de longitud é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  és connex si per tot parell de vèrtexs  existeix un camí que comença en  i acaba en .

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  vèrtex té  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  és adjacent al vèrtex  si  ( 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, , es compleix el següent teorema: .

Un graf és complet si conté el màxim nombre d'arestes/arcs possible. En el cas d'un graf aquest és  i en el cas d'un graf dirigit .

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

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  (el graf complet bipartit de 6 vèrtexs) ni  (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 . 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:
• Temps de creació: ( 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: on és el nombre de vèrtex i 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 ) però en espai pot ser molt ineficient (quan conté molts zeros, en el cas de grafs esparsos). Utilitzem la matriu per a grafs densos ().

Exemple

Tenim un graf amb vèrtex i 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 (suposant que un booleà ocupa un bit, serien ).

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 (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), , una ordenació topològica de  és una ordenació dels seus vèrtexs tal que per tot parell de vèrtexs , si existeix un camí d' a  al graf , aleshores  no pot aparèixer abans que  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 és un graf amb pesos (weighted graph) si cada aresta (o arc ) del graf té associat un valor . Si ,  és un graf amb pesos positius; si , és un graf amb pesos no negatius.

Donat un graf  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  qualssevol, diem que un camí d' a  é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' a . (Si no hi ha cap cami d' a  diem, per definició, que el pes és ).

L'algorisme de Dijkstra (pronunciació: 'd3Ikstra) calcula els camins mínims d'un vèrtexs  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 .

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 .
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  això correspon a un temps , i en total, per a tots els vèrtexs, això correspon a un temps .
3. Hi ha el cost de les inicialitzacions, que és .

En total, el cost del recorregut en amplada és .

Cost del recorregut en profunditat

1. El bucle exterior es fa  vegades.
2. Per cada iteració, el bucle interior es fa per tots els adjacents a cada vèrtex amb un cost . En total, el cost és .
3. El cost de les inicialitzacions és .

En total, el cost del recorregut en profunditat és .

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 en cas pitjor. Com que s'hi han d'afegir els  vèrtexs del grup, en total el cost és .
• 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 . En total: .

Enllaços rellevants

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

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: algorithmics, eda, fib, universitat

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: .
• Esborrar un element: cost de cercar l'element () + cost de treure'l de la taula (varia segons el mecanisme d'eliminació, possiblement ).

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: ;
    - al final de la llista, recorrent-la sencera: .
• Cercar un element: 
• Esborrar un element:

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 , 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 amb un cost .

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. clau associada a un node del sub-arbre esquerra d'un node amb clau es compleix que .
2. clau associada a un node del sub-arbre dret d'un node amb clau es compleix que .

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' claus:
    - cas millor: (arbre equilibrat);
    - cas mitjà: , suposant que totes les permutacions de les  claus són igualment probables;
    - cas pitjor:  (ordenats).
• Inserir una clau en un arbre d' nodes: , on  és l'alçada de l'arbre.
  
• Cercar una clau en un arbre d'alçada : .
• 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 .
• 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 . 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 (on h és l'alçada de l'abre, ) i el d'una rotació és .

• Esborrar una clau: poden caldre fins a passos per a rebalancejar l'arbre.

Cues de prioritat

Es creen en temps 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: .
• Consultar-ne el valor mínim o màxim: .
• Esborrar-ne el valor mínim o màxim: .
• Inserir un element: .

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

No comments
© Siegfried-Angel Gevatter Pujals, 2011. | Permalink | License | Post tags: algorithmics, eda, fib, universitat