I'm sure that you are aware of the fact that floats representation in any programming language is limited by the precision of the internal binary representations. In other words, you can never have an exact float representation - there will always be some precision associated with the float you are working with. The simplest example is the difference in precision between the float and double types in C.

Suppose I have the following code fragment:

Both result.score and input->raw_cut_off are of type float, and can have positive and negative values. When compared with the greater than or equal ( >= ) operator, it is not always that condition is true - for the precision reasons shortly mentioned above.

As I already said, there is no precision specification for equality operators in C. But it is quite simple to "invent" precision specification; e.g. if I wanted to test for equality only, I could write

In this example, I'm effectively asking for 6-digit precision for the equality comparison of floating-point values. Note, that if you replace that 0.000001 with the actual precision limit of the floating type you are using, you will be "exactly" comparing floating-point numbers - up to that type's precision, of course .

The first-most example with the >= operator can be rewritten as

where precision is exactly what it is named, e.g. precision = 0.000001.

Sources used:

• comment by Randy A. Ynchausti
• scientific programming

The idea is: if the original audio stream in the file is already compressed (most of the time it is), then you do not need to recompress it - and do not need libmp3lame or any other audio codec! To achieve the "ffmpeg direct stream copy" functionality, you can add one of the two options:
-vcodec copy will direct-stream-copy video (no re-compression),
-acodec copy will direct-stream-copy audio (no re-compression).

In other words, ffmpeg option -acodec copy should just copy the original audio from input file to output file without alteration, and will not require any audio codecs support.

Sample command line could be (in the example, a 1-minute fragment of the input file is just copied into the output file):

ffmpeg -t 00:01:00 -i movie.avi -vcodec copy -acodec copy preview.avi

This tip is based on the information initially obtained from the ffmpeg-user mailing list archive for June of 2005.

There are 3 possible solutions: using INSERT IGNORE, REPLACE, or INSERT ... ON DUPLICATE KEY UPDATE.

Imagine we have a table:

Now imagine that we have an automatic pipeline importing transcripts meta-data from Ensembl, and that due to various reasons the pipeline might be broken at any step of execution. Thus, we need to ensure two things: 1) repeated executions of the pipeline will not destroy our database, and 2) repeated executions will not die due to 'duplicate primary key' errors.

Method 1: using REPLACE

It's very simple:

If the record exists, it will be overwritten; if it does not yet exist, it will be created.
However, using this method isn't efficient for our case: we do not need to overwrite existing records, it's fine just to skip them.

Method 2: using INSERT IGNORE
Also very simple:

Here, if the 'ensembl_transcript_id' is already present in the database, it will be silently skipped (ignored). (To be more precise, here's a quote from MySQL reference manual: "If you use the IGNORE keyword, errors that occur while executing the INSERT statement are treated as warnings instead. For example, without IGNORE, a row that duplicates an existing UNIQUE index or PRIMARY KEY value in the table causes a duplicate-key error and the statement is aborted.".) If the record doesn't yet exist, it will be created.

This second method has several potential weaknesses, including non-abortion of the query in case any other problem occurs (see the manual). Thus it should be used if previously tested without the IGNORE keyword.

There is one more option: to use INSERT ... ON DUPLICATE KEY UPDATE syntax, and in the UPDATE part just do nothing do some meaningless (empty) operation, like calculating 0+0 (Geoffray suggests doing the id=id assignment for the MySQL optimization engine to ignore this operation). Advantage of this method is that it only ignores duplicate key events, and still aborts on other errors.

As a final notice: this post was inspired by Xaprb. I'd also advise to consult his other post on writing flexible SQL queries.

To synchronously and simultaneously loop over two sequences:

To loop over a sequence with both key and value:

To loop over dictionary, again with key and value:

To loop over some sorted sequence, but without modifying the original sequence (beware the use of set() in this example):

For looping sorted dictionaries, see also How to sort Python dict (dictionary).

You can also define the Python ksort() function similar to that found in PHP:

(example taken from TheScript forum)